<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE PolyKinds #-}</span><span>
</span><span id="line-2"></span><span class="hs-pragma">{-# LANGUAGE Trustworthy #-}</span><span>
</span><span id="line-3"></span><span>
</span><span id="line-4"></span><span class="hs-comment">-- |</span><span>
</span><span id="line-5"></span><span class="hs-comment">-- Language.Haskell.TH.Lib.Internal exposes some additional functionality that</span><span>
</span><span id="line-6"></span><span class="hs-comment">-- is used internally in GHC's integration with Template Haskell. This is not a</span><span>
</span><span id="line-7"></span><span class="hs-comment">-- part of the public API, and as such, there are no API guarantees for this</span><span>
</span><span id="line-8"></span><span class="hs-comment">-- module from version to version.</span><span>
</span><span id="line-9"></span><span>
</span><span id="line-10"></span><span class="hs-comment">-- Why do we have both Language.Haskell.TH.Lib.Internal and</span><span>
</span><span id="line-11"></span><span class="hs-comment">-- Language.Haskell.TH.Lib? Ultimately, it's because the functions in the</span><span>
</span><span id="line-12"></span><span class="hs-comment">-- former (which are tailored for GHC's use) need different type signatures</span><span>
</span><span id="line-13"></span><span class="hs-comment">-- than the ones in the latter. Syncing up the Internal type signatures would</span><span>
</span><span id="line-14"></span><span class="hs-comment">-- involve a massive amount of breaking changes, so for the time being, we</span><span>
</span><span id="line-15"></span><span class="hs-comment">-- relegate as many changes as we can to just the Internal module, where it</span><span>
</span><span id="line-16"></span><span class="hs-comment">-- is safe to break things.</span><span>
</span><span id="line-17"></span><span>
</span><span id="line-18"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">Language.Haskell.TH.Lib.Internal</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-19"></span><span>
</span><span id="line-20"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html"><span class="hs-identifier">Language.Haskell.TH.Syntax</span></a></span><span> </span><span class="hs-keyword">hiding</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Role"><span class="hs-identifier">Role</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#InjectivityAnn"><span class="hs-identifier">InjectivityAnn</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-21"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html"><span class="hs-identifier">Language.Haskell.TH.Syntax</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">TH</span></span><span>
</span><span id="line-22"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Control.Applicative.html#"><span class="hs-identifier">Control.Applicative</span></a></span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#liftA"><span class="hs-identifier">liftA</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#liftA2"><span class="hs-identifier">liftA2</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-23"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../base/src/Data.Kind.html#"><span class="hs-identifier">Data.Kind</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Kind</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Type"><span class="hs-identifier">Type</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-24"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Word.html#"><span class="hs-identifier">Data.Word</span></a></span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier">Word8</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-25"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/GHC.Exts.html#"><span class="hs-identifier">GHC.Exts</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#TYPE"><span class="hs-identifier">TYPE</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-26"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Prelude.html#"><span class="hs-identifier">Prelude</span></a></span><span>
</span><span id="line-27"></span><span>
</span><span id="line-28"></span><span class="hs-comment">----------------------------------------------------------</span><span>
</span><span id="line-29"></span><span class="hs-comment">-- * Type synonyms</span><span>
</span><span id="line-30"></span><span class="hs-comment">----------------------------------------------------------</span><span>
</span><span id="line-31"></span><span>
</span><span id="line-32"></span><span class="hs-comment">-- Since GHC 8.8 is currently the minimum boot compiler version that we must</span><span>
</span><span id="line-33"></span><span class="hs-comment">-- support, we must use inline kind signatures to make TExpQ and CodeQ</span><span>
</span><span id="line-34"></span><span class="hs-comment">-- levity polymorphic. When we drop support for GHC 8.8, we can instead use</span><span>
</span><span id="line-35"></span><span class="hs-comment">-- standalone kind signatures, which are provided as comments.</span><span>
</span><span id="line-36"></span><span>
</span><span id="line-37"></span><span class="hs-comment">-- | Levity-polymorphic since /template-haskell-2.17.0.0/.</span><span>
</span><span id="line-38"></span><span class="hs-comment">-- type TExpQ :: TYPE r -&gt; Kind.Type</span><span>
</span><span id="line-39"></span><span class="hs-keyword">type</span><span> </span><span id="TExpQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#TExpQ"><span class="hs-identifier hs-var">TExpQ</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679166892"><span id="local-6989586621679166891"><span class="annot"><a href="#local-6989586621679166891"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#TYPE"><span class="hs-identifier hs-type">TYPE</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166892"><span class="hs-identifier hs-type">r</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TExp"><span class="hs-identifier hs-type">TExp</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166891"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-40"></span><span>
</span><span id="line-41"></span><span class="hs-comment">-- type CodeQ :: TYPE r -&gt; Kind.Type</span><span>
</span><span id="line-42"></span><span class="hs-keyword">type</span><span> </span><span id="CodeQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#CodeQ"><span class="hs-identifier hs-var">CodeQ</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Code"><span class="hs-identifier hs-type">Code</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Prim.html#TYPE"><span class="hs-identifier hs-type">TYPE</span></a></span><span> </span><span id="local-6989586621679166888"><span class="annot"><a href="#local-6989586621679166888"><span class="hs-identifier hs-type hs-type">r</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Type"><span class="hs-identifier hs-type">Kind.Type</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-43"></span><span>
</span><span id="line-44"></span><span class="hs-keyword">type</span><span> </span><span id="InfoQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#InfoQ"><span class="hs-identifier hs-var">InfoQ</span></a></span></span><span>               </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Info"><span class="hs-identifier hs-type">Info</span></a></span><span>
</span><span id="line-45"></span><span class="hs-keyword">type</span><span> </span><span id="PatQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#PatQ"><span class="hs-identifier hs-var">PatQ</span></a></span></span><span>                </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span>
</span><span id="line-46"></span><span class="hs-keyword">type</span><span> </span><span id="FieldPatQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#FieldPatQ"><span class="hs-identifier hs-var">FieldPatQ</span></a></span></span><span>           </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FieldPat"><span class="hs-identifier hs-type">FieldPat</span></a></span><span>
</span><span id="line-47"></span><span class="hs-keyword">type</span><span> </span><span id="ExpQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#ExpQ"><span class="hs-identifier hs-var">ExpQ</span></a></span></span><span>                </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span>
</span><span id="line-48"></span><span class="hs-keyword">type</span><span> </span><span id="DecQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#DecQ"><span class="hs-identifier hs-var">DecQ</span></a></span></span><span>                </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span><span>
</span><span id="line-49"></span><span class="hs-keyword">type</span><span> </span><span id="DecsQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#DecsQ"><span class="hs-identifier hs-var">DecsQ</span></a></span></span><span>               </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-50"></span><span class="hs-keyword">type</span><span> </span><span id="Decs"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#Decs"><span class="hs-identifier hs-var">Decs</span></a></span></span><span>                </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-comment">-- Defined as it is more convenient to wire-in</span><span>
</span><span id="line-51"></span><span class="hs-keyword">type</span><span> </span><span id="ConQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#ConQ"><span class="hs-identifier hs-var">ConQ</span></a></span></span><span>                </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span><span>
</span><span id="line-52"></span><span class="hs-keyword">type</span><span> </span><span id="TypeQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#TypeQ"><span class="hs-identifier hs-var">TypeQ</span></a></span></span><span>               </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span>
</span><span id="line-53"></span><span class="hs-keyword">type</span><span> </span><span id="KindQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#KindQ"><span class="hs-identifier hs-var">KindQ</span></a></span></span><span>               </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span>
</span><span id="line-54"></span><span class="hs-keyword">type</span><span> </span><span id="TyLitQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#TyLitQ"><span class="hs-identifier hs-var">TyLitQ</span></a></span></span><span>              </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyLit"><span class="hs-identifier hs-type">TyLit</span></a></span><span>
</span><span id="line-55"></span><span class="hs-keyword">type</span><span> </span><span id="CxtQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#CxtQ"><span class="hs-identifier hs-var">CxtQ</span></a></span></span><span>                </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span>
</span><span id="line-56"></span><span class="hs-keyword">type</span><span> </span><span id="PredQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#PredQ"><span class="hs-identifier hs-var">PredQ</span></a></span></span><span>               </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pred"><span class="hs-identifier hs-type">Pred</span></a></span><span>
</span><span id="line-57"></span><span class="hs-keyword">type</span><span> </span><span id="DerivClauseQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#DerivClauseQ"><span class="hs-identifier hs-var">DerivClauseQ</span></a></span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivClause"><span class="hs-identifier hs-type">DerivClause</span></a></span><span>
</span><span id="line-58"></span><span class="hs-keyword">type</span><span> </span><span id="MatchQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#MatchQ"><span class="hs-identifier hs-var">MatchQ</span></a></span></span><span>              </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Match"><span class="hs-identifier hs-type">Match</span></a></span><span>
</span><span id="line-59"></span><span class="hs-keyword">type</span><span> </span><span id="ClauseQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#ClauseQ"><span class="hs-identifier hs-var">ClauseQ</span></a></span></span><span>             </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Clause"><span class="hs-identifier hs-type">Clause</span></a></span><span>
</span><span id="line-60"></span><span class="hs-keyword">type</span><span> </span><span id="BodyQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#BodyQ"><span class="hs-identifier hs-var">BodyQ</span></a></span></span><span>               </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Body"><span class="hs-identifier hs-type">Body</span></a></span><span>
</span><span id="line-61"></span><span class="hs-keyword">type</span><span> </span><span id="GuardQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#GuardQ"><span class="hs-identifier hs-var">GuardQ</span></a></span></span><span>              </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Guard"><span class="hs-identifier hs-type">Guard</span></a></span><span>
</span><span id="line-62"></span><span class="hs-keyword">type</span><span> </span><span id="StmtQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#StmtQ"><span class="hs-identifier hs-var">StmtQ</span></a></span></span><span>               </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Stmt"><span class="hs-identifier hs-type">Stmt</span></a></span><span>
</span><span id="line-63"></span><span class="hs-keyword">type</span><span> </span><span id="RangeQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#RangeQ"><span class="hs-identifier hs-var">RangeQ</span></a></span></span><span>              </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Range"><span class="hs-identifier hs-type">Range</span></a></span><span>
</span><span id="line-64"></span><span class="hs-keyword">type</span><span> </span><span id="SourceStrictnessQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#SourceStrictnessQ"><span class="hs-identifier hs-var">SourceStrictnessQ</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#SourceStrictness"><span class="hs-identifier hs-type">SourceStrictness</span></a></span><span>
</span><span id="line-65"></span><span class="hs-keyword">type</span><span> </span><span id="SourceUnpackednessQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#SourceUnpackednessQ"><span class="hs-identifier hs-var">SourceUnpackednessQ</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#SourceUnpackedness"><span class="hs-identifier hs-type">SourceUnpackedness</span></a></span><span>
</span><span id="line-66"></span><span class="hs-keyword">type</span><span> </span><span id="BangQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#BangQ"><span class="hs-identifier hs-var">BangQ</span></a></span></span><span>               </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Bang"><span class="hs-identifier hs-type">Bang</span></a></span><span>
</span><span id="line-67"></span><span class="hs-keyword">type</span><span> </span><span id="BangTypeQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#BangTypeQ"><span class="hs-identifier hs-var">BangTypeQ</span></a></span></span><span>           </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#BangType"><span class="hs-identifier hs-type">BangType</span></a></span><span>
</span><span id="line-68"></span><span class="hs-keyword">type</span><span> </span><span id="VarBangTypeQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#VarBangTypeQ"><span class="hs-identifier hs-var">VarBangTypeQ</span></a></span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#VarBangType"><span class="hs-identifier hs-type">VarBangType</span></a></span><span>
</span><span id="line-69"></span><span class="hs-keyword">type</span><span> </span><span id="StrictTypeQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#StrictTypeQ"><span class="hs-identifier hs-var">StrictTypeQ</span></a></span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#StrictType"><span class="hs-identifier hs-type">StrictType</span></a></span><span>
</span><span id="line-70"></span><span class="hs-keyword">type</span><span> </span><span id="VarStrictTypeQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#VarStrictTypeQ"><span class="hs-identifier hs-var">VarStrictTypeQ</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#VarStrictType"><span class="hs-identifier hs-type">VarStrictType</span></a></span><span>
</span><span id="line-71"></span><span class="hs-keyword">type</span><span> </span><span id="FieldExpQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#FieldExpQ"><span class="hs-identifier hs-var">FieldExpQ</span></a></span></span><span>           </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FieldExp"><span class="hs-identifier hs-type">FieldExp</span></a></span><span>
</span><span id="line-72"></span><span class="hs-keyword">type</span><span> </span><span id="RuleBndrQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#RuleBndrQ"><span class="hs-identifier hs-var">RuleBndrQ</span></a></span></span><span>           </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#RuleBndr"><span class="hs-identifier hs-type">RuleBndr</span></a></span><span>
</span><span id="line-73"></span><span class="hs-keyword">type</span><span> </span><span id="TySynEqnQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#TySynEqnQ"><span class="hs-identifier hs-var">TySynEqnQ</span></a></span></span><span>           </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TySynEqn"><span class="hs-identifier hs-type">TySynEqn</span></a></span><span>
</span><span id="line-74"></span><span class="hs-keyword">type</span><span> </span><span id="PatSynDirQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#PatSynDirQ"><span class="hs-identifier hs-var">PatSynDirQ</span></a></span></span><span>          </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#PatSynDir"><span class="hs-identifier hs-type">PatSynDir</span></a></span><span>
</span><span id="line-75"></span><span class="hs-keyword">type</span><span> </span><span id="PatSynArgsQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#PatSynArgsQ"><span class="hs-identifier hs-var">PatSynArgsQ</span></a></span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#PatSynArgs"><span class="hs-identifier hs-type">PatSynArgs</span></a></span><span>
</span><span id="line-76"></span><span class="hs-keyword">type</span><span> </span><span id="FamilyResultSigQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#FamilyResultSigQ"><span class="hs-identifier hs-var">FamilyResultSigQ</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FamilyResultSig"><span class="hs-identifier hs-type">FamilyResultSig</span></a></span><span>
</span><span id="line-77"></span><span class="hs-keyword">type</span><span> </span><span id="DerivStrategyQ"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#DerivStrategyQ"><span class="hs-identifier hs-var">DerivStrategyQ</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivStrategy"><span class="hs-identifier hs-type">DerivStrategy</span></a></span><span>
</span><span id="line-78"></span><span>
</span><span id="line-79"></span><span class="hs-comment">-- must be defined here for DsMeta to find it</span><span>
</span><span id="line-80"></span><span class="hs-keyword">type</span><span> </span><span id="Role"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#Role"><span class="hs-identifier hs-var">Role</span></a></span></span><span>                </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Role"><span class="hs-identifier hs-type">TH.Role</span></a></span><span>
</span><span id="line-81"></span><span class="hs-keyword">type</span><span> </span><span id="InjectivityAnn"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#InjectivityAnn"><span class="hs-identifier hs-var">InjectivityAnn</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#InjectivityAnn"><span class="hs-identifier hs-type">TH.InjectivityAnn</span></a></span><span>
</span><span id="line-82"></span><span>
</span><span id="line-83"></span><span class="hs-keyword">type</span><span> </span><span id="TyVarBndrUnit"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#TyVarBndrUnit"><span class="hs-identifier hs-var">TyVarBndrUnit</span></a></span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-84"></span><span class="hs-keyword">type</span><span> </span><span id="TyVarBndrSpec"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#TyVarBndrSpec"><span class="hs-identifier hs-var">TyVarBndrSpec</span></a></span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Specificity"><span class="hs-identifier hs-type">Specificity</span></a></span><span>
</span><span id="line-85"></span><span>
</span><span id="line-86"></span><span class="hs-comment">----------------------------------------------------------</span><span>
</span><span id="line-87"></span><span class="hs-comment">-- * Lowercase pattern syntax functions</span><span>
</span><span id="line-88"></span><span class="hs-comment">----------------------------------------------------------</span><span>
</span><span id="line-89"></span><span>
</span><span id="line-90"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#intPrimL"><span class="hs-identifier hs-type">intPrimL</span></a></span><span>    </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Lit"><span class="hs-identifier hs-type">Lit</span></a></span><span>
</span><span id="line-91"></span><span id="intPrimL"><span class="annot"><span class="annottext">intPrimL :: Integer -&gt; Lit
</span><a href="Language.Haskell.TH.Lib.Internal.html#intPrimL"><span class="hs-identifier hs-var hs-var">intPrimL</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Lit
</span><a href="Language.Haskell.TH.Syntax.html#IntPrimL"><span class="hs-identifier hs-var">IntPrimL</span></a></span><span>
</span><span id="line-92"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#wordPrimL"><span class="hs-identifier hs-type">wordPrimL</span></a></span><span>    </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Lit"><span class="hs-identifier hs-type">Lit</span></a></span><span>
</span><span id="line-93"></span><span id="wordPrimL"><span class="annot"><span class="annottext">wordPrimL :: Integer -&gt; Lit
</span><a href="Language.Haskell.TH.Lib.Internal.html#wordPrimL"><span class="hs-identifier hs-var hs-var">wordPrimL</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Lit
</span><a href="Language.Haskell.TH.Syntax.html#WordPrimL"><span class="hs-identifier hs-var">WordPrimL</span></a></span><span>
</span><span id="line-94"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#floatPrimL"><span class="hs-identifier hs-type">floatPrimL</span></a></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Real.html#Rational"><span class="hs-identifier hs-type">Rational</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Lit"><span class="hs-identifier hs-type">Lit</span></a></span><span>
</span><span id="line-95"></span><span id="floatPrimL"><span class="annot"><span class="annottext">floatPrimL :: Rational -&gt; Lit
</span><a href="Language.Haskell.TH.Lib.Internal.html#floatPrimL"><span class="hs-identifier hs-var hs-var">floatPrimL</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Rational -&gt; Lit
</span><a href="Language.Haskell.TH.Syntax.html#FloatPrimL"><span class="hs-identifier hs-var">FloatPrimL</span></a></span><span>
</span><span id="line-96"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#doublePrimL"><span class="hs-identifier hs-type">doublePrimL</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Real.html#Rational"><span class="hs-identifier hs-type">Rational</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Lit"><span class="hs-identifier hs-type">Lit</span></a></span><span>
</span><span id="line-97"></span><span id="doublePrimL"><span class="annot"><span class="annottext">doublePrimL :: Rational -&gt; Lit
</span><a href="Language.Haskell.TH.Lib.Internal.html#doublePrimL"><span class="hs-identifier hs-var hs-var">doublePrimL</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Rational -&gt; Lit
</span><a href="Language.Haskell.TH.Syntax.html#DoublePrimL"><span class="hs-identifier hs-var">DoublePrimL</span></a></span><span>
</span><span id="line-98"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#integerL"><span class="hs-identifier hs-type">integerL</span></a></span><span>    </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Lit"><span class="hs-identifier hs-type">Lit</span></a></span><span>
</span><span id="line-99"></span><span id="integerL"><span class="annot"><span class="annottext">integerL :: Integer -&gt; Lit
</span><a href="Language.Haskell.TH.Lib.Internal.html#integerL"><span class="hs-identifier hs-var hs-var">integerL</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Lit
</span><a href="Language.Haskell.TH.Syntax.html#IntegerL"><span class="hs-identifier hs-var">IntegerL</span></a></span><span>
</span><span id="line-100"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#charL"><span class="hs-identifier hs-type">charL</span></a></span><span>       </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Char"><span class="hs-identifier hs-type">Char</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Lit"><span class="hs-identifier hs-type">Lit</span></a></span><span>
</span><span id="line-101"></span><span id="charL"><span class="annot"><span class="annottext">charL :: Char -&gt; Lit
</span><a href="Language.Haskell.TH.Lib.Internal.html#charL"><span class="hs-identifier hs-var hs-var">charL</span></a></span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; Lit
</span><a href="Language.Haskell.TH.Syntax.html#CharL"><span class="hs-identifier hs-var">CharL</span></a></span><span>
</span><span id="line-102"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#charPrimL"><span class="hs-identifier hs-type">charPrimL</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Char"><span class="hs-identifier hs-type">Char</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Lit"><span class="hs-identifier hs-type">Lit</span></a></span><span>
</span><span id="line-103"></span><span id="charPrimL"><span class="annot"><span class="annottext">charPrimL :: Char -&gt; Lit
</span><a href="Language.Haskell.TH.Lib.Internal.html#charPrimL"><span class="hs-identifier hs-var hs-var">charPrimL</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; Lit
</span><a href="Language.Haskell.TH.Syntax.html#CharPrimL"><span class="hs-identifier hs-var">CharPrimL</span></a></span><span>
</span><span id="line-104"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#stringL"><span class="hs-identifier hs-type">stringL</span></a></span><span>     </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Lit"><span class="hs-identifier hs-type">Lit</span></a></span><span>
</span><span id="line-105"></span><span id="stringL"><span class="annot"><span class="annottext">stringL :: String -&gt; Lit
</span><a href="Language.Haskell.TH.Lib.Internal.html#stringL"><span class="hs-identifier hs-var hs-var">stringL</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; Lit
</span><a href="Language.Haskell.TH.Syntax.html#StringL"><span class="hs-identifier hs-var">StringL</span></a></span><span>
</span><span id="line-106"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#stringPrimL"><span class="hs-identifier hs-type">stringPrimL</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Lit"><span class="hs-identifier hs-type">Lit</span></a></span><span>
</span><span id="line-107"></span><span id="stringPrimL"><span class="annot"><span class="annottext">stringPrimL :: [Word8] -&gt; Lit
</span><a href="Language.Haskell.TH.Lib.Internal.html#stringPrimL"><span class="hs-identifier hs-var hs-var">stringPrimL</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Word8] -&gt; Lit
</span><a href="Language.Haskell.TH.Syntax.html#StringPrimL"><span class="hs-identifier hs-var">StringPrimL</span></a></span><span>
</span><span id="line-108"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#bytesPrimL"><span class="hs-identifier hs-type">bytesPrimL</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Bytes"><span class="hs-identifier hs-type">Bytes</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Lit"><span class="hs-identifier hs-type">Lit</span></a></span><span>
</span><span id="line-109"></span><span id="bytesPrimL"><span class="annot"><span class="annottext">bytesPrimL :: Bytes -&gt; Lit
</span><a href="Language.Haskell.TH.Lib.Internal.html#bytesPrimL"><span class="hs-identifier hs-var hs-var">bytesPrimL</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bytes -&gt; Lit
</span><a href="Language.Haskell.TH.Syntax.html#BytesPrimL"><span class="hs-identifier hs-var">BytesPrimL</span></a></span><span>
</span><span id="line-110"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#rationalL"><span class="hs-identifier hs-type">rationalL</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Real.html#Rational"><span class="hs-identifier hs-type">Rational</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Lit"><span class="hs-identifier hs-type">Lit</span></a></span><span>
</span><span id="line-111"></span><span id="rationalL"><span class="annot"><span class="annottext">rationalL :: Rational -&gt; Lit
</span><a href="Language.Haskell.TH.Lib.Internal.html#rationalL"><span class="hs-identifier hs-var hs-var">rationalL</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Rational -&gt; Lit
</span><a href="Language.Haskell.TH.Syntax.html#RationalL"><span class="hs-identifier hs-var">RationalL</span></a></span><span>
</span><span id="line-112"></span><span>
</span><span id="line-113"></span><span id="local-6989586621679167280"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#litP"><span class="hs-identifier hs-type">litP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167280"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Lit"><span class="hs-identifier hs-type">Lit</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167280"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span></span><span>
</span><span id="line-114"></span><span id="litP"><span class="annot"><span class="annottext">litP :: forall (m :: * -&gt; *). Quote m =&gt; Lit -&gt; m Pat
</span><a href="Language.Haskell.TH.Lib.Internal.html#litP"><span class="hs-identifier hs-var hs-var">litP</span></a></span></span><span> </span><span id="local-6989586621679166836"><span class="annot"><span class="annottext">Lit
</span><a href="#local-6989586621679166836"><span class="hs-identifier hs-var">l</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Pat -&gt; m Pat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Lit -&gt; Pat
</span><a href="Language.Haskell.TH.Syntax.html#LitP"><span class="hs-identifier hs-var">LitP</span></a></span><span> </span><span class="annot"><span class="annottext">Lit
</span><a href="#local-6989586621679166836"><span class="hs-identifier hs-var">l</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-115"></span><span>
</span><span id="line-116"></span><span id="local-6989586621679167274"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#varP"><span class="hs-identifier hs-type">varP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167274"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167274"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span></span><span>
</span><span id="line-117"></span><span id="varP"><span class="annot"><span class="annottext">varP :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Pat
</span><a href="Language.Haskell.TH.Lib.Internal.html#varP"><span class="hs-identifier hs-var hs-var">varP</span></a></span></span><span> </span><span id="local-6989586621679166830"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166830"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Pat -&gt; m Pat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; Pat
</span><a href="Language.Haskell.TH.Syntax.html#VarP"><span class="hs-identifier hs-var">VarP</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166830"><span class="hs-identifier hs-var">v</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-118"></span><span>
</span><span id="line-119"></span><span id="local-6989586621679167272"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tupP"><span class="hs-identifier hs-type">tupP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167272"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167272"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167272"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span></span><span>
</span><span id="line-120"></span><span id="tupP"><span class="annot"><span class="annottext">tupP :: forall (m :: * -&gt; *). Quote m =&gt; [m Pat] -&gt; m Pat
</span><a href="Language.Haskell.TH.Lib.Internal.html#tupP"><span class="hs-identifier hs-var hs-var">tupP</span></a></span></span><span> </span><span id="local-6989586621679166820"><span class="annot"><span class="annottext">[m Pat]
</span><a href="#local-6989586621679166820"><span class="hs-identifier hs-var">ps</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166819"><span class="annot"><span class="annottext">[Pat]
</span><a href="#local-6989586621679166819"><span class="hs-identifier hs-var">ps1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Pat] -&gt; m [Pat]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Pat]
</span><a href="#local-6989586621679166820"><span class="hs-identifier hs-var">ps</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Pat -&gt; m Pat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Pat] -&gt; Pat
</span><a href="Language.Haskell.TH.Syntax.html#TupP"><span class="hs-identifier hs-var">TupP</span></a></span><span> </span><span class="annot"><span class="annottext">[Pat]
</span><a href="#local-6989586621679166819"><span class="hs-identifier hs-var">ps1</span></a></span><span class="hs-special">)</span><span class="hs-special">}</span><span>
</span><span id="line-121"></span><span>
</span><span id="line-122"></span><span id="local-6989586621679166816"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unboxedTupP"><span class="hs-identifier hs-type">unboxedTupP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166816"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679166816"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166816"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span></span><span>
</span><span id="line-123"></span><span id="unboxedTupP"><span class="annot"><span class="annottext">unboxedTupP :: forall (m :: * -&gt; *). Quote m =&gt; [m Pat] -&gt; m Pat
</span><a href="Language.Haskell.TH.Lib.Internal.html#unboxedTupP"><span class="hs-identifier hs-var hs-var">unboxedTupP</span></a></span></span><span> </span><span id="local-6989586621679166808"><span class="annot"><span class="annottext">[m Pat]
</span><a href="#local-6989586621679166808"><span class="hs-identifier hs-var">ps</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166807"><span class="annot"><span class="annottext">[Pat]
</span><a href="#local-6989586621679166807"><span class="hs-identifier hs-var">ps1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Pat] -&gt; m [Pat]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Pat]
</span><a href="#local-6989586621679166808"><span class="hs-identifier hs-var">ps</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Pat -&gt; m Pat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Pat] -&gt; Pat
</span><a href="Language.Haskell.TH.Syntax.html#UnboxedTupP"><span class="hs-identifier hs-var">UnboxedTupP</span></a></span><span> </span><span class="annot"><span class="annottext">[Pat]
</span><a href="#local-6989586621679166807"><span class="hs-identifier hs-var">ps1</span></a></span><span class="hs-special">)</span><span class="hs-special">}</span><span>
</span><span id="line-124"></span><span>
</span><span id="line-125"></span><span id="local-6989586621679167266"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unboxedSumP"><span class="hs-identifier hs-type">unboxedSumP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167266"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167266"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#SumAlt"><span class="hs-identifier hs-type">SumAlt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#SumArity"><span class="hs-identifier hs-type">SumArity</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167266"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span></span><span>
</span><span id="line-126"></span><span id="unboxedSumP"><span class="annot"><span class="annottext">unboxedSumP :: forall (m :: * -&gt; *). Quote m =&gt; m Pat -&gt; SumAlt -&gt; SumAlt -&gt; m Pat
</span><a href="Language.Haskell.TH.Lib.Internal.html#unboxedSumP"><span class="hs-identifier hs-var hs-var">unboxedSumP</span></a></span></span><span> </span><span id="local-6989586621679166799"><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166799"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679166798"><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679166798"><span class="hs-identifier hs-var">alt</span></a></span></span><span> </span><span id="local-6989586621679166797"><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679166797"><span class="hs-identifier hs-var">arity</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166796"><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166796"><span class="hs-identifier hs-var">p1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166799"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Pat -&gt; m Pat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Pat -&gt; SumAlt -&gt; SumAlt -&gt; Pat
</span><a href="Language.Haskell.TH.Syntax.html#UnboxedSumP"><span class="hs-identifier hs-var">UnboxedSumP</span></a></span><span> </span><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166796"><span class="hs-identifier hs-var">p1</span></a></span><span> </span><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679166798"><span class="hs-identifier hs-var">alt</span></a></span><span> </span><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679166797"><span class="hs-identifier hs-var">arity</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-127"></span><span>
</span><span id="line-128"></span><span id="local-6989586621679167263"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#conP"><span class="hs-identifier hs-type">conP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167263"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167263"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167263"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span></span><span>
</span><span id="line-129"></span><span id="conP"><span class="annot"><span class="annottext">conP :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; [m Pat] -&gt; m Pat
</span><a href="Language.Haskell.TH.Lib.Internal.html#conP"><span class="hs-identifier hs-var hs-var">conP</span></a></span></span><span> </span><span id="local-6989586621679166787"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166787"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679166786"><span class="annot"><span class="annottext">[m Pat]
</span><a href="#local-6989586621679166786"><span class="hs-identifier hs-var">ps</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679166785"><span class="annot"><span class="annottext">[Pat]
</span><a href="#local-6989586621679166785"><span class="hs-identifier hs-var">ps'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Pat] -&gt; m [Pat]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Pat]
</span><a href="#local-6989586621679166786"><span class="hs-identifier hs-var">ps</span></a></span><span>
</span><span id="line-130"></span><span>               </span><span class="annot"><span class="annottext">Pat -&gt; m Pat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; [Pat] -&gt; Pat
</span><a href="Language.Haskell.TH.Syntax.html#ConP"><span class="hs-identifier hs-var">ConP</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166787"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">[Pat]
</span><a href="#local-6989586621679166785"><span class="hs-identifier hs-var">ps'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-131"></span><span id="local-6989586621679167261"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixP"><span class="hs-identifier hs-type">infixP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167261"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167261"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167261"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167261"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span></span><span>
</span><span id="line-132"></span><span id="infixP"><span class="annot"><span class="annottext">infixP :: forall (m :: * -&gt; *). Quote m =&gt; m Pat -&gt; Name -&gt; m Pat -&gt; m Pat
</span><a href="Language.Haskell.TH.Lib.Internal.html#infixP"><span class="hs-identifier hs-var hs-var">infixP</span></a></span></span><span> </span><span id="local-6989586621679166777"><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166777"><span class="hs-identifier hs-var">p1</span></a></span></span><span> </span><span id="local-6989586621679166776"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166776"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679166775"><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166775"><span class="hs-identifier hs-var">p2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679166774"><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166774"><span class="hs-identifier hs-var">p1'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166777"><span class="hs-identifier hs-var">p1</span></a></span><span>
</span><span id="line-133"></span><span>                    </span><span id="local-6989586621679166773"><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166773"><span class="hs-identifier hs-var">p2'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166775"><span class="hs-identifier hs-var">p2</span></a></span><span>
</span><span id="line-134"></span><span>                    </span><span class="annot"><span class="annottext">Pat -&gt; m Pat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Pat -&gt; Name -&gt; Pat -&gt; Pat
</span><a href="Language.Haskell.TH.Syntax.html#InfixP"><span class="hs-identifier hs-var">InfixP</span></a></span><span> </span><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166774"><span class="hs-identifier hs-var">p1'</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166776"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166773"><span class="hs-identifier hs-var">p2'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-135"></span><span id="local-6989586621679166771"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#uInfixP"><span class="hs-identifier hs-type">uInfixP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166771"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166771"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166771"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166771"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span></span><span>
</span><span id="line-136"></span><span id="uInfixP"><span class="annot"><span class="annottext">uInfixP :: forall (m :: * -&gt; *). Quote m =&gt; m Pat -&gt; Name -&gt; m Pat -&gt; m Pat
</span><a href="Language.Haskell.TH.Lib.Internal.html#uInfixP"><span class="hs-identifier hs-var hs-var">uInfixP</span></a></span></span><span> </span><span id="local-6989586621679166763"><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166763"><span class="hs-identifier hs-var">p1</span></a></span></span><span> </span><span id="local-6989586621679166762"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166762"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679166761"><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166761"><span class="hs-identifier hs-var">p2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679166760"><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166760"><span class="hs-identifier hs-var">p1'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166763"><span class="hs-identifier hs-var">p1</span></a></span><span>
</span><span id="line-137"></span><span>                     </span><span id="local-6989586621679166759"><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166759"><span class="hs-identifier hs-var">p2'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166761"><span class="hs-identifier hs-var">p2</span></a></span><span>
</span><span id="line-138"></span><span>                     </span><span class="annot"><span class="annottext">Pat -&gt; m Pat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Pat -&gt; Name -&gt; Pat -&gt; Pat
</span><a href="Language.Haskell.TH.Syntax.html#UInfixP"><span class="hs-identifier hs-var">UInfixP</span></a></span><span> </span><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166760"><span class="hs-identifier hs-var">p1'</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166762"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166759"><span class="hs-identifier hs-var">p2'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-139"></span><span id="local-6989586621679167258"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#parensP"><span class="hs-identifier hs-type">parensP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167258"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167258"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167258"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span></span><span>
</span><span id="line-140"></span><span id="parensP"><span class="annot"><span class="annottext">parensP :: forall (m :: * -&gt; *). Quote m =&gt; m Pat -&gt; m Pat
</span><a href="Language.Haskell.TH.Lib.Internal.html#parensP"><span class="hs-identifier hs-var hs-var">parensP</span></a></span></span><span> </span><span id="local-6989586621679166751"><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166751"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679166750"><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166750"><span class="hs-identifier hs-var">p'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166751"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-141"></span><span>               </span><span class="annot"><span class="annottext">Pat -&gt; m Pat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Pat -&gt; Pat
</span><a href="Language.Haskell.TH.Syntax.html#ParensP"><span class="hs-identifier hs-var">ParensP</span></a></span><span> </span><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166750"><span class="hs-identifier hs-var">p'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-142"></span><span>
</span><span id="line-143"></span><span id="local-6989586621679166748"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tildeP"><span class="hs-identifier hs-type">tildeP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166748"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166748"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166748"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span></span><span>
</span><span id="line-144"></span><span id="tildeP"><span class="annot"><span class="annottext">tildeP :: forall (m :: * -&gt; *). Quote m =&gt; m Pat -&gt; m Pat
</span><a href="Language.Haskell.TH.Lib.Internal.html#tildeP"><span class="hs-identifier hs-var hs-var">tildeP</span></a></span></span><span> </span><span id="local-6989586621679166742"><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166742"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679166741"><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166741"><span class="hs-identifier hs-var">p'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166742"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-145"></span><span>              </span><span class="annot"><span class="annottext">Pat -&gt; m Pat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Pat -&gt; Pat
</span><a href="Language.Haskell.TH.Syntax.html#TildeP"><span class="hs-identifier hs-var">TildeP</span></a></span><span> </span><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166741"><span class="hs-identifier hs-var">p'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-146"></span><span id="local-6989586621679166739"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#bangP"><span class="hs-identifier hs-type">bangP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166739"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166739"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166739"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span></span><span>
</span><span id="line-147"></span><span id="bangP"><span class="annot"><span class="annottext">bangP :: forall (m :: * -&gt; *). Quote m =&gt; m Pat -&gt; m Pat
</span><a href="Language.Haskell.TH.Lib.Internal.html#bangP"><span class="hs-identifier hs-var hs-var">bangP</span></a></span></span><span> </span><span id="local-6989586621679166733"><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166733"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679166732"><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166732"><span class="hs-identifier hs-var">p'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166733"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-148"></span><span>             </span><span class="annot"><span class="annottext">Pat -&gt; m Pat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Pat -&gt; Pat
</span><a href="Language.Haskell.TH.Syntax.html#BangP"><span class="hs-identifier hs-var">BangP</span></a></span><span> </span><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166732"><span class="hs-identifier hs-var">p'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-149"></span><span id="local-6989586621679167254"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#asP"><span class="hs-identifier hs-type">asP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span></span><span>
</span><span id="line-150"></span><span id="asP"><span class="annot"><span class="annottext">asP :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Pat -&gt; m Pat
</span><a href="Language.Haskell.TH.Lib.Internal.html#asP"><span class="hs-identifier hs-var hs-var">asP</span></a></span></span><span> </span><span id="local-6989586621679166725"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166725"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679166724"><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166724"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679166723"><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166723"><span class="hs-identifier hs-var">p'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166724"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-151"></span><span>             </span><span class="annot"><span class="annottext">Pat -&gt; m Pat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; Pat -&gt; Pat
</span><a href="Language.Haskell.TH.Syntax.html#AsP"><span class="hs-identifier hs-var">AsP</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166725"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166723"><span class="hs-identifier hs-var">p'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-152"></span><span id="local-6989586621679167252"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#wildP"><span class="hs-identifier hs-type">wildP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167252"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167252"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span></span><span>
</span><span id="line-153"></span><span id="wildP"><span class="annot"><span class="annottext">wildP :: forall (m :: * -&gt; *). Quote m =&gt; m Pat
</span><a href="Language.Haskell.TH.Lib.Internal.html#wildP"><span class="hs-identifier hs-var hs-var">wildP</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Pat -&gt; m Pat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">Pat
</span><a href="Language.Haskell.TH.Syntax.html#WildP"><span class="hs-identifier hs-var">WildP</span></a></span><span>
</span><span id="line-154"></span><span id="local-6989586621679167250"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#recP"><span class="hs-identifier hs-type">recP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167250"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167250"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FieldPat"><span class="hs-identifier hs-type">FieldPat</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167250"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span></span><span>
</span><span id="line-155"></span><span id="recP"><span class="annot"><span class="annottext">recP :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; [m FieldPat] -&gt; m Pat
</span><a href="Language.Haskell.TH.Lib.Internal.html#recP"><span class="hs-identifier hs-var hs-var">recP</span></a></span></span><span> </span><span id="local-6989586621679166709"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166709"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679166708"><span class="annot"><span class="annottext">[m FieldPat]
</span><a href="#local-6989586621679166708"><span class="hs-identifier hs-var">fps</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679166707"><span class="annot"><span class="annottext">[FieldPat]
</span><a href="#local-6989586621679166707"><span class="hs-identifier hs-var">fps'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m FieldPat] -&gt; m [FieldPat]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m FieldPat]
</span><a href="#local-6989586621679166708"><span class="hs-identifier hs-var">fps</span></a></span><span>
</span><span id="line-156"></span><span>                </span><span class="annot"><span class="annottext">Pat -&gt; m Pat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; [FieldPat] -&gt; Pat
</span><a href="Language.Haskell.TH.Syntax.html#RecP"><span class="hs-identifier hs-var">RecP</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166709"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">[FieldPat]
</span><a href="#local-6989586621679166707"><span class="hs-identifier hs-var">fps'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-157"></span><span id="local-6989586621679166705"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#listP"><span class="hs-identifier hs-type">listP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166705"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679166705"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166705"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span></span><span>
</span><span id="line-158"></span><span id="listP"><span class="annot"><span class="annottext">listP :: forall (m :: * -&gt; *). Quote m =&gt; [m Pat] -&gt; m Pat
</span><a href="Language.Haskell.TH.Lib.Internal.html#listP"><span class="hs-identifier hs-var hs-var">listP</span></a></span></span><span> </span><span id="local-6989586621679166697"><span class="annot"><span class="annottext">[m Pat]
</span><a href="#local-6989586621679166697"><span class="hs-identifier hs-var">ps</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679166696"><span class="annot"><span class="annottext">[Pat]
</span><a href="#local-6989586621679166696"><span class="hs-identifier hs-var">ps'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Pat] -&gt; m [Pat]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Pat]
</span><a href="#local-6989586621679166697"><span class="hs-identifier hs-var">ps</span></a></span><span>
</span><span id="line-159"></span><span>              </span><span class="annot"><span class="annottext">Pat -&gt; m Pat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Pat] -&gt; Pat
</span><a href="Language.Haskell.TH.Syntax.html#ListP"><span class="hs-identifier hs-var">ListP</span></a></span><span> </span><span class="annot"><span class="annottext">[Pat]
</span><a href="#local-6989586621679166696"><span class="hs-identifier hs-var">ps'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-160"></span><span id="local-6989586621679167247"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sigP"><span class="hs-identifier hs-type">sigP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167247"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167247"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167247"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167247"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span></span><span>
</span><span id="line-161"></span><span id="sigP"><span class="annot"><span class="annottext">sigP :: forall (m :: * -&gt; *). Quote m =&gt; m Pat -&gt; m Type -&gt; m Pat
</span><a href="Language.Haskell.TH.Lib.Internal.html#sigP"><span class="hs-identifier hs-var hs-var">sigP</span></a></span></span><span> </span><span id="local-6989586621679166688"><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166688"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679166687"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679166687"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679166686"><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166686"><span class="hs-identifier hs-var">p'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166688"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-162"></span><span>              </span><span id="local-6989586621679166685"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679166685"><span class="hs-identifier hs-var">t'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679166687"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-163"></span><span>              </span><span class="annot"><span class="annottext">Pat -&gt; m Pat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Pat -&gt; Type -&gt; Pat
</span><a href="Language.Haskell.TH.Syntax.html#SigP"><span class="hs-identifier hs-var">SigP</span></a></span><span> </span><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166686"><span class="hs-identifier hs-var">p'</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679166685"><span class="hs-identifier hs-var">t'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-164"></span><span id="local-6989586621679167245"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#viewP"><span class="hs-identifier hs-type">viewP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167245"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167245"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167245"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167245"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span></span><span>
</span><span id="line-165"></span><span id="viewP"><span class="annot"><span class="annottext">viewP :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Pat -&gt; m Pat
</span><a href="Language.Haskell.TH.Lib.Internal.html#viewP"><span class="hs-identifier hs-var hs-var">viewP</span></a></span></span><span> </span><span id="local-6989586621679166677"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166677"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span id="local-6989586621679166676"><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166676"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679166675"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166675"><span class="hs-identifier hs-var">e'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166677"><span class="hs-identifier hs-var">e</span></a></span><span>
</span><span id="line-166"></span><span>               </span><span id="local-6989586621679166674"><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166674"><span class="hs-identifier hs-var">p'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166676"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-167"></span><span>               </span><span class="annot"><span class="annottext">Pat -&gt; m Pat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Pat -&gt; Pat
</span><a href="Language.Haskell.TH.Syntax.html#ViewP"><span class="hs-identifier hs-var">ViewP</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166675"><span class="hs-identifier hs-var">e'</span></a></span><span> </span><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166674"><span class="hs-identifier hs-var">p'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-168"></span><span>
</span><span id="line-169"></span><span id="local-6989586621679167243"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fieldPat"><span class="hs-identifier hs-type">fieldPat</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167243"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167243"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167243"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FieldPat"><span class="hs-identifier hs-type">FieldPat</span></a></span></span><span>
</span><span id="line-170"></span><span id="fieldPat"><span class="annot"><span class="annottext">fieldPat :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Pat -&gt; m FieldPat
</span><a href="Language.Haskell.TH.Lib.Internal.html#fieldPat"><span class="hs-identifier hs-var hs-var">fieldPat</span></a></span></span><span> </span><span id="local-6989586621679166667"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166667"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679166666"><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166666"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679166665"><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166665"><span class="hs-identifier hs-var">p'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166666"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-171"></span><span>                  </span><span class="annot"><span class="annottext">FieldPat -&gt; m FieldPat
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166667"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166665"><span class="hs-identifier hs-var">p'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-172"></span><span>
</span><span id="line-173"></span><span>
</span><span id="line-174"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-175"></span><span class="hs-comment">-- *   Stmt</span><span>
</span><span id="line-176"></span><span>
</span><span id="line-177"></span><span id="local-6989586621679167241"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#bindS"><span class="hs-identifier hs-type">bindS</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167241"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167241"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167241"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167241"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Stmt"><span class="hs-identifier hs-type">Stmt</span></a></span></span><span>
</span><span id="line-178"></span><span id="bindS"><span class="annot"><span class="annottext">bindS :: forall (m :: * -&gt; *). Quote m =&gt; m Pat -&gt; m Exp -&gt; m Stmt
</span><a href="Language.Haskell.TH.Lib.Internal.html#bindS"><span class="hs-identifier hs-var hs-var">bindS</span></a></span></span><span> </span><span id="local-6989586621679166660"><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166660"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679166659"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166659"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Pat -&gt; Exp -&gt; Stmt) -&gt; m Pat -&gt; m Exp -&gt; m Stmt
forall (f :: * -&gt; *) a b c.
Applicative f =&gt;
(a -&gt; b -&gt; c) -&gt; f a -&gt; f b -&gt; f c
</span><a href="../../base/src/GHC.Base.html#liftA2"><span class="hs-identifier hs-var">liftA2</span></a></span><span> </span><span class="annot"><span class="annottext">Pat -&gt; Exp -&gt; Stmt
</span><a href="Language.Haskell.TH.Syntax.html#BindS"><span class="hs-identifier hs-var">BindS</span></a></span><span> </span><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166660"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166659"><span class="hs-identifier hs-var">e</span></a></span><span>
</span><span id="line-179"></span><span>
</span><span id="line-180"></span><span id="local-6989586621679167236"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#letS"><span class="hs-identifier hs-type">letS</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167236"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167236"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167236"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Stmt"><span class="hs-identifier hs-type">Stmt</span></a></span></span><span>
</span><span id="line-181"></span><span id="letS"><span class="annot"><span class="annottext">letS :: forall (m :: * -&gt; *). Quote m =&gt; [m Dec] -&gt; m Stmt
</span><a href="Language.Haskell.TH.Lib.Internal.html#letS"><span class="hs-identifier hs-var hs-var">letS</span></a></span></span><span> </span><span id="local-6989586621679166650"><span class="annot"><span class="annottext">[m Dec]
</span><a href="#local-6989586621679166650"><span class="hs-identifier hs-var">ds</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166649"><span class="annot"><span class="annottext">[Dec]
</span><a href="#local-6989586621679166649"><span class="hs-identifier hs-var">ds1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Dec] -&gt; m [Dec]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Dec]
</span><a href="#local-6989586621679166650"><span class="hs-identifier hs-var">ds</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Stmt -&gt; m Stmt
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Dec] -&gt; Stmt
</span><a href="Language.Haskell.TH.Syntax.html#LetS"><span class="hs-identifier hs-var">LetS</span></a></span><span> </span><span class="annot"><span class="annottext">[Dec]
</span><a href="#local-6989586621679166649"><span class="hs-identifier hs-var">ds1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-182"></span><span>
</span><span id="line-183"></span><span id="local-6989586621679167234"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#noBindS"><span class="hs-identifier hs-type">noBindS</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167234"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167234"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167234"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Stmt"><span class="hs-identifier hs-type">Stmt</span></a></span></span><span>
</span><span id="line-184"></span><span id="noBindS"><span class="annot"><span class="annottext">noBindS :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Stmt
</span><a href="Language.Haskell.TH.Lib.Internal.html#noBindS"><span class="hs-identifier hs-var hs-var">noBindS</span></a></span></span><span> </span><span id="local-6989586621679166642"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166642"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166641"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166641"><span class="hs-identifier hs-var">e1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166642"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Stmt -&gt; m Stmt
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Stmt
</span><a href="Language.Haskell.TH.Syntax.html#NoBindS"><span class="hs-identifier hs-var">NoBindS</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166641"><span class="hs-identifier hs-var">e1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-185"></span><span>
</span><span id="line-186"></span><span id="local-6989586621679167232"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#parS"><span class="hs-identifier hs-type">parS</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167232"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167232"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Stmt"><span class="hs-identifier hs-type">Stmt</span></a></span><span class="hs-special">]</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167232"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Stmt"><span class="hs-identifier hs-type">Stmt</span></a></span></span><span>
</span><span id="line-187"></span><span id="parS"><span class="annot"><span class="annottext">parS :: forall (m :: * -&gt; *). Quote m =&gt; [[m Stmt]] -&gt; m Stmt
</span><a href="Language.Haskell.TH.Lib.Internal.html#parS"><span class="hs-identifier hs-var hs-var">parS</span></a></span></span><span> </span><span id="local-6989586621679166630"><span class="annot"><span class="annottext">[[m Stmt]]
</span><a href="#local-6989586621679166630"><span class="hs-identifier hs-var">sss</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166629"><span class="annot"><span class="annottext">[[Stmt]]
</span><a href="#local-6989586621679166629"><span class="hs-identifier hs-var">sss1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">([m Stmt] -&gt; m [Stmt]) -&gt; [[m Stmt]] -&gt; m [[Stmt]]
forall (t :: * -&gt; *) (f :: * -&gt; *) a b.
(Traversable t, Applicative f) =&gt;
(a -&gt; f b) -&gt; t a -&gt; f (t b)
</span><a href="../../base/src/Data.Traversable.html#traverse"><span class="hs-identifier hs-var">traverse</span></a></span><span> </span><span class="annot"><span class="annottext">[m Stmt] -&gt; m [Stmt]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[[m Stmt]]
</span><a href="#local-6989586621679166630"><span class="hs-identifier hs-var">sss</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Stmt -&gt; m Stmt
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[[Stmt]] -&gt; Stmt
</span><a href="Language.Haskell.TH.Syntax.html#ParS"><span class="hs-identifier hs-var">ParS</span></a></span><span> </span><span class="annot"><span class="annottext">[[Stmt]]
</span><a href="#local-6989586621679166629"><span class="hs-identifier hs-var">sss1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-188"></span><span>
</span><span id="line-189"></span><span id="local-6989586621679167227"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#recS"><span class="hs-identifier hs-type">recS</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167227"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167227"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Stmt"><span class="hs-identifier hs-type">Stmt</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167227"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Stmt"><span class="hs-identifier hs-type">Stmt</span></a></span></span><span>
</span><span id="line-190"></span><span id="recS"><span class="annot"><span class="annottext">recS :: forall (m :: * -&gt; *). Quote m =&gt; [m Stmt] -&gt; m Stmt
</span><a href="Language.Haskell.TH.Lib.Internal.html#recS"><span class="hs-identifier hs-var hs-var">recS</span></a></span></span><span> </span><span id="local-6989586621679166619"><span class="annot"><span class="annottext">[m Stmt]
</span><a href="#local-6989586621679166619"><span class="hs-identifier hs-var">ss</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166618"><span class="annot"><span class="annottext">[Stmt]
</span><a href="#local-6989586621679166618"><span class="hs-identifier hs-var">ss1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Stmt] -&gt; m [Stmt]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Stmt]
</span><a href="#local-6989586621679166619"><span class="hs-identifier hs-var">ss</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Stmt -&gt; m Stmt
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Stmt] -&gt; Stmt
</span><a href="Language.Haskell.TH.Syntax.html#RecS"><span class="hs-identifier hs-var">RecS</span></a></span><span> </span><span class="annot"><span class="annottext">[Stmt]
</span><a href="#local-6989586621679166618"><span class="hs-identifier hs-var">ss1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-191"></span><span>
</span><span id="line-192"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-193"></span><span class="hs-comment">-- *   Range</span><span>
</span><span id="line-194"></span><span>
</span><span id="line-195"></span><span id="local-6989586621679167225"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fromR"><span class="hs-identifier hs-type">fromR</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167225"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167225"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167225"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Range"><span class="hs-identifier hs-type">Range</span></a></span></span><span>
</span><span id="line-196"></span><span id="fromR"><span class="annot"><span class="annottext">fromR :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Range
</span><a href="Language.Haskell.TH.Lib.Internal.html#fromR"><span class="hs-identifier hs-var hs-var">fromR</span></a></span></span><span> </span><span id="local-6989586621679166610"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166610"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166609"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166609"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166610"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Range -&gt; m Range
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Range
</span><a href="Language.Haskell.TH.Syntax.html#FromR"><span class="hs-identifier hs-var">FromR</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166609"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-197"></span><span>
</span><span id="line-198"></span><span id="local-6989586621679167222"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fromThenR"><span class="hs-identifier hs-type">fromThenR</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167222"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167222"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167222"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167222"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Range"><span class="hs-identifier hs-type">Range</span></a></span></span><span>
</span><span id="line-199"></span><span id="fromThenR"><span class="annot"><span class="annottext">fromThenR :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Exp -&gt; m Range
</span><a href="Language.Haskell.TH.Lib.Internal.html#fromThenR"><span class="hs-identifier hs-var hs-var">fromThenR</span></a></span></span><span> </span><span id="local-6989586621679166600"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166600"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679166599"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166599"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166598"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166598"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166600"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166597"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166597"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166599"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Range -&gt; m Range
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Exp -&gt; Range
</span><a href="Language.Haskell.TH.Syntax.html#FromThenR"><span class="hs-identifier hs-var">FromThenR</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166598"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166597"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-200"></span><span>
</span><span id="line-201"></span><span id="local-6989586621679166595"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fromToR"><span class="hs-identifier hs-type">fromToR</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166595"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166595"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166595"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166595"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Range"><span class="hs-identifier hs-type">Range</span></a></span></span><span>
</span><span id="line-202"></span><span id="fromToR"><span class="annot"><span class="annottext">fromToR :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Exp -&gt; m Range
</span><a href="Language.Haskell.TH.Lib.Internal.html#fromToR"><span class="hs-identifier hs-var hs-var">fromToR</span></a></span></span><span> </span><span id="local-6989586621679166587"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166587"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679166586"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166586"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166585"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166585"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166587"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166584"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166584"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166586"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Range -&gt; m Range
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Exp -&gt; Range
</span><a href="Language.Haskell.TH.Syntax.html#FromToR"><span class="hs-identifier hs-var">FromToR</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166585"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166584"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-203"></span><span>
</span><span id="line-204"></span><span id="local-6989586621679167219"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fromThenToR"><span class="hs-identifier hs-type">fromThenToR</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167219"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167219"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167219"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167219"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167219"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Range"><span class="hs-identifier hs-type">Range</span></a></span></span><span>
</span><span id="line-205"></span><span id="fromThenToR"><span class="annot"><span class="annottext">fromThenToR :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Exp -&gt; m Exp -&gt; m Range
</span><a href="Language.Haskell.TH.Lib.Internal.html#fromThenToR"><span class="hs-identifier hs-var hs-var">fromThenToR</span></a></span></span><span> </span><span id="local-6989586621679166574"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166574"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679166573"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166573"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span id="local-6989586621679166572"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166572"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166571"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166571"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166574"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166570"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166570"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166573"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166569"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166569"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166572"><span class="hs-identifier hs-var">z</span></a></span><span class="hs-special">;</span><span>
</span><span id="line-206"></span><span>                         </span><span class="annot"><span class="annottext">Range -&gt; m Range
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Exp -&gt; Exp -&gt; Range
</span><a href="Language.Haskell.TH.Syntax.html#FromThenToR"><span class="hs-identifier hs-var">FromThenToR</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166571"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166570"><span class="hs-identifier hs-var">b</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166569"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-207"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-208"></span><span class="hs-comment">-- *   Body</span><span>
</span><span id="line-209"></span><span>
</span><span id="line-210"></span><span id="local-6989586621679167217"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#normalB"><span class="hs-identifier hs-type">normalB</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167217"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167217"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167217"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Body"><span class="hs-identifier hs-type">Body</span></a></span></span><span>
</span><span id="line-211"></span><span id="normalB"><span class="annot"><span class="annottext">normalB :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Body
</span><a href="Language.Haskell.TH.Lib.Internal.html#normalB"><span class="hs-identifier hs-var hs-var">normalB</span></a></span></span><span> </span><span id="local-6989586621679166562"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166562"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166561"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166561"><span class="hs-identifier hs-var">e1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166562"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Body -&gt; m Body
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Body
</span><a href="Language.Haskell.TH.Syntax.html#NormalB"><span class="hs-identifier hs-var">NormalB</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166561"><span class="hs-identifier hs-var">e1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-212"></span><span>
</span><span id="line-213"></span><span id="local-6989586621679167214"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#guardedB"><span class="hs-identifier hs-type">guardedB</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167214"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167214"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Guard"><span class="hs-identifier hs-type">Guard</span></a></span><span class="hs-special">,</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167214"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Body"><span class="hs-identifier hs-type">Body</span></a></span></span><span>
</span><span id="line-214"></span><span id="guardedB"><span class="annot"><span class="annottext">guardedB :: forall (m :: * -&gt; *). Quote m =&gt; [m (Guard, Exp)] -&gt; m Body
</span><a href="Language.Haskell.TH.Lib.Internal.html#guardedB"><span class="hs-identifier hs-var hs-var">guardedB</span></a></span></span><span> </span><span id="local-6989586621679166552"><span class="annot"><span class="annottext">[m (Guard, Exp)]
</span><a href="#local-6989586621679166552"><span class="hs-identifier hs-var">ges</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166551"><span class="annot"><span class="annottext">[(Guard, Exp)]
</span><a href="#local-6989586621679166551"><span class="hs-identifier hs-var">ges'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m (Guard, Exp)] -&gt; m [(Guard, Exp)]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m (Guard, Exp)]
</span><a href="#local-6989586621679166552"><span class="hs-identifier hs-var">ges</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Body -&gt; m Body
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[(Guard, Exp)] -&gt; Body
</span><a href="Language.Haskell.TH.Syntax.html#GuardedB"><span class="hs-identifier hs-var">GuardedB</span></a></span><span> </span><span class="annot"><span class="annottext">[(Guard, Exp)]
</span><a href="#local-6989586621679166551"><span class="hs-identifier hs-var">ges'</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-215"></span><span>
</span><span id="line-216"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-217"></span><span class="hs-comment">-- *   Guard</span><span>
</span><span id="line-218"></span><span>
</span><span id="line-219"></span><span id="local-6989586621679167211"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#normalG"><span class="hs-identifier hs-type">normalG</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167211"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167211"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167211"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Guard"><span class="hs-identifier hs-type">Guard</span></a></span></span><span>
</span><span id="line-220"></span><span id="normalG"><span class="annot"><span class="annottext">normalG :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Guard
</span><a href="Language.Haskell.TH.Lib.Internal.html#normalG"><span class="hs-identifier hs-var hs-var">normalG</span></a></span></span><span> </span><span id="local-6989586621679166543"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166543"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166542"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166542"><span class="hs-identifier hs-var">e1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166543"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Guard -&gt; m Guard
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Guard
</span><a href="Language.Haskell.TH.Syntax.html#NormalG"><span class="hs-identifier hs-var">NormalG</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166542"><span class="hs-identifier hs-var">e1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-221"></span><span>
</span><span id="line-222"></span><span id="local-6989586621679167209"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#normalGE"><span class="hs-identifier hs-type">normalGE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167209"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167209"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167209"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167209"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Guard"><span class="hs-identifier hs-type">Guard</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-223"></span><span id="normalGE"><span class="annot"><span class="annottext">normalGE :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Exp -&gt; m (Guard, Exp)
</span><a href="Language.Haskell.TH.Lib.Internal.html#normalGE"><span class="hs-identifier hs-var hs-var">normalGE</span></a></span></span><span> </span><span id="local-6989586621679166534"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166534"><span class="hs-identifier hs-var">g</span></a></span></span><span> </span><span id="local-6989586621679166533"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166533"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166532"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166532"><span class="hs-identifier hs-var">g1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166534"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166531"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166531"><span class="hs-identifier hs-var">e1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166533"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(Guard, Exp) -&gt; m (Guard, Exp)
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Guard
</span><a href="Language.Haskell.TH.Syntax.html#NormalG"><span class="hs-identifier hs-var">NormalG</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166532"><span class="hs-identifier hs-var">g1</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166531"><span class="hs-identifier hs-var">e1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-224"></span><span>
</span><span id="line-225"></span><span id="local-6989586621679167207"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#patG"><span class="hs-identifier hs-type">patG</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167207"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167207"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Stmt"><span class="hs-identifier hs-type">Stmt</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167207"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Guard"><span class="hs-identifier hs-type">Guard</span></a></span></span><span>
</span><span id="line-226"></span><span id="patG"><span class="annot"><span class="annottext">patG :: forall (m :: * -&gt; *). Quote m =&gt; [m Stmt] -&gt; m Guard
</span><a href="Language.Haskell.TH.Lib.Internal.html#patG"><span class="hs-identifier hs-var hs-var">patG</span></a></span></span><span> </span><span id="local-6989586621679166522"><span class="annot"><span class="annottext">[m Stmt]
</span><a href="#local-6989586621679166522"><span class="hs-identifier hs-var">ss</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166521"><span class="annot"><span class="annottext">[Stmt]
</span><a href="#local-6989586621679166521"><span class="hs-identifier hs-var">ss'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Stmt] -&gt; m [Stmt]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Stmt]
</span><a href="#local-6989586621679166522"><span class="hs-identifier hs-var">ss</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Guard -&gt; m Guard
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Stmt] -&gt; Guard
</span><a href="Language.Haskell.TH.Syntax.html#PatG"><span class="hs-identifier hs-var">PatG</span></a></span><span> </span><span class="annot"><span class="annottext">[Stmt]
</span><a href="#local-6989586621679166521"><span class="hs-identifier hs-var">ss'</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-227"></span><span>
</span><span id="line-228"></span><span id="local-6989586621679167205"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#patGE"><span class="hs-identifier hs-type">patGE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167205"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167205"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Stmt"><span class="hs-identifier hs-type">Stmt</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167205"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167205"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Guard"><span class="hs-identifier hs-type">Guard</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-229"></span><span id="patGE"><span class="annot"><span class="annottext">patGE :: forall (m :: * -&gt; *).
Quote m =&gt;
[m Stmt] -&gt; m Exp -&gt; m (Guard, Exp)
</span><a href="Language.Haskell.TH.Lib.Internal.html#patGE"><span class="hs-identifier hs-var hs-var">patGE</span></a></span></span><span> </span><span id="local-6989586621679166511"><span class="annot"><span class="annottext">[m Stmt]
</span><a href="#local-6989586621679166511"><span class="hs-identifier hs-var">ss</span></a></span></span><span> </span><span id="local-6989586621679166510"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166510"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166509"><span class="annot"><span class="annottext">[Stmt]
</span><a href="#local-6989586621679166509"><span class="hs-identifier hs-var">ss'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Stmt] -&gt; m [Stmt]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Stmt]
</span><a href="#local-6989586621679166511"><span class="hs-identifier hs-var">ss</span></a></span><span class="hs-special">;</span><span>
</span><span id="line-230"></span><span>                  </span><span id="local-6989586621679166508"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166508"><span class="hs-identifier hs-var">e'</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166510"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">;</span><span>
</span><span id="line-231"></span><span>                  </span><span class="annot"><span class="annottext">(Guard, Exp) -&gt; m (Guard, Exp)
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Stmt] -&gt; Guard
</span><a href="Language.Haskell.TH.Syntax.html#PatG"><span class="hs-identifier hs-var">PatG</span></a></span><span> </span><span class="annot"><span class="annottext">[Stmt]
</span><a href="#local-6989586621679166509"><span class="hs-identifier hs-var">ss'</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166508"><span class="hs-identifier hs-var">e'</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-232"></span><span>
</span><span id="line-233"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-234"></span><span class="hs-comment">-- *   Match and Clause</span><span>
</span><span id="line-235"></span><span>
</span><span id="line-236"></span><span class="hs-comment">-- | Use with 'caseE'</span><span>
</span><span id="line-237"></span><span id="local-6989586621679167203"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#match"><span class="hs-identifier hs-type">match</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167203"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167203"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167203"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Body"><span class="hs-identifier hs-type">Body</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167203"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167203"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Match"><span class="hs-identifier hs-type">Match</span></a></span></span><span>
</span><span id="line-238"></span><span id="match"><span class="annot"><span class="annottext">match :: forall (m :: * -&gt; *).
Quote m =&gt;
m Pat -&gt; m Body -&gt; [m Dec] -&gt; m Match
</span><a href="Language.Haskell.TH.Lib.Internal.html#match"><span class="hs-identifier hs-var hs-var">match</span></a></span></span><span> </span><span id="local-6989586621679166498"><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166498"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679166497"><span class="annot"><span class="annottext">m Body
</span><a href="#local-6989586621679166497"><span class="hs-identifier hs-var">rhs</span></a></span></span><span> </span><span id="local-6989586621679166496"><span class="annot"><span class="annottext">[m Dec]
</span><a href="#local-6989586621679166496"><span class="hs-identifier hs-var">ds</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166495"><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166495"><span class="hs-identifier hs-var">p'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166498"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">;</span><span>
</span><span id="line-239"></span><span>                      </span><span id="local-6989586621679166494"><span class="annot"><span class="annottext">Body
</span><a href="#local-6989586621679166494"><span class="hs-identifier hs-var">r'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Body
</span><a href="#local-6989586621679166497"><span class="hs-identifier hs-var">rhs</span></a></span><span class="hs-special">;</span><span>
</span><span id="line-240"></span><span>                      </span><span id="local-6989586621679166493"><span class="annot"><span class="annottext">[Dec]
</span><a href="#local-6989586621679166493"><span class="hs-identifier hs-var">ds'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Dec] -&gt; m [Dec]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Dec]
</span><a href="#local-6989586621679166496"><span class="hs-identifier hs-var">ds</span></a></span><span class="hs-special">;</span><span>
</span><span id="line-241"></span><span>                      </span><span class="annot"><span class="annottext">Match -&gt; m Match
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Pat -&gt; Body -&gt; [Dec] -&gt; Match
</span><a href="Language.Haskell.TH.Syntax.html#Match"><span class="hs-identifier hs-var">Match</span></a></span><span> </span><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166495"><span class="hs-identifier hs-var">p'</span></a></span><span> </span><span class="annot"><span class="annottext">Body
</span><a href="#local-6989586621679166494"><span class="hs-identifier hs-var">r'</span></a></span><span> </span><span class="annot"><span class="annottext">[Dec]
</span><a href="#local-6989586621679166493"><span class="hs-identifier hs-var">ds'</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-242"></span><span>
</span><span id="line-243"></span><span class="hs-comment">-- | Use with 'funD'</span><span>
</span><span id="line-244"></span><span id="local-6989586621679167201"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#clause"><span class="hs-identifier hs-type">clause</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167201"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167201"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167201"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Body"><span class="hs-identifier hs-type">Body</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167201"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167201"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Clause"><span class="hs-identifier hs-type">Clause</span></a></span></span><span>
</span><span id="line-245"></span><span id="clause"><span class="annot"><span class="annottext">clause :: forall (m :: * -&gt; *).
Quote m =&gt;
[m Pat] -&gt; m Body -&gt; [m Dec] -&gt; m Clause
</span><a href="Language.Haskell.TH.Lib.Internal.html#clause"><span class="hs-identifier hs-var hs-var">clause</span></a></span></span><span> </span><span id="local-6989586621679166480"><span class="annot"><span class="annottext">[m Pat]
</span><a href="#local-6989586621679166480"><span class="hs-identifier hs-var">ps</span></a></span></span><span> </span><span id="local-6989586621679166479"><span class="annot"><span class="annottext">m Body
</span><a href="#local-6989586621679166479"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span id="local-6989586621679166478"><span class="annot"><span class="annottext">[m Dec]
</span><a href="#local-6989586621679166478"><span class="hs-identifier hs-var">ds</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166477"><span class="annot"><span class="annottext">[Pat]
</span><a href="#local-6989586621679166477"><span class="hs-identifier hs-var">ps'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Pat] -&gt; m [Pat]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Pat]
</span><a href="#local-6989586621679166480"><span class="hs-identifier hs-var">ps</span></a></span><span class="hs-special">;</span><span>
</span><span id="line-246"></span><span>                      </span><span id="local-6989586621679166476"><span class="annot"><span class="annottext">Body
</span><a href="#local-6989586621679166476"><span class="hs-identifier hs-var">r'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Body
</span><a href="#local-6989586621679166479"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">;</span><span>
</span><span id="line-247"></span><span>                      </span><span id="local-6989586621679166475"><span class="annot"><span class="annottext">[Dec]
</span><a href="#local-6989586621679166475"><span class="hs-identifier hs-var">ds'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Dec] -&gt; m [Dec]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Dec]
</span><a href="#local-6989586621679166478"><span class="hs-identifier hs-var">ds</span></a></span><span class="hs-special">;</span><span>
</span><span id="line-248"></span><span>                      </span><span class="annot"><span class="annottext">Clause -&gt; m Clause
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Pat] -&gt; Body -&gt; [Dec] -&gt; Clause
</span><a href="Language.Haskell.TH.Syntax.html#Clause"><span class="hs-identifier hs-var">Clause</span></a></span><span> </span><span class="annot"><span class="annottext">[Pat]
</span><a href="#local-6989586621679166477"><span class="hs-identifier hs-var">ps'</span></a></span><span> </span><span class="annot"><span class="annottext">Body
</span><a href="#local-6989586621679166476"><span class="hs-identifier hs-var">r'</span></a></span><span> </span><span class="annot"><span class="annottext">[Dec]
</span><a href="#local-6989586621679166475"><span class="hs-identifier hs-var">ds'</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-249"></span><span>
</span><span id="line-250"></span><span>
</span><span id="line-251"></span><span class="hs-comment">---------------------------------------------------------------------------</span><span>
</span><span id="line-252"></span><span class="hs-comment">-- *   Exp</span><span>
</span><span id="line-253"></span><span>
</span><span id="line-254"></span><span class="hs-comment">-- | Dynamically binding a variable (unhygenic)</span><span>
</span><span id="line-255"></span><span id="local-6989586621679167199"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#dyn"><span class="hs-identifier hs-type">dyn</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167199"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167199"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-256"></span><span id="dyn"><span class="annot"><span class="annottext">dyn :: forall (m :: * -&gt; *). Quote m =&gt; String -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#dyn"><span class="hs-identifier hs-var hs-var">dyn</span></a></span></span><span> </span><span id="local-6989586621679166468"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679166468"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#VarE"><span class="hs-identifier hs-var">VarE</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Name
</span><a href="Language.Haskell.TH.Syntax.html#mkName"><span class="hs-identifier hs-var">mkName</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679166468"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-257"></span><span>
</span><span id="line-258"></span><span id="local-6989586621679167197"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#varE"><span class="hs-identifier hs-type">varE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167197"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167197"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-259"></span><span id="varE"><span class="annot"><span class="annottext">varE :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#varE"><span class="hs-identifier hs-var hs-var">varE</span></a></span></span><span> </span><span id="local-6989586621679166462"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166462"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#VarE"><span class="hs-identifier hs-var">VarE</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166462"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-260"></span><span>
</span><span id="line-261"></span><span id="local-6989586621679166461"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#conE"><span class="hs-identifier hs-type">conE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166461"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166461"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-262"></span><span id="conE"><span class="annot"><span class="annottext">conE :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#conE"><span class="hs-identifier hs-var hs-var">conE</span></a></span></span><span> </span><span id="local-6989586621679166456"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166456"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>  </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#ConE"><span class="hs-identifier hs-var">ConE</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166456"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-263"></span><span>
</span><span id="line-264"></span><span id="local-6989586621679167194"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#litE"><span class="hs-identifier hs-type">litE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167194"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Lit"><span class="hs-identifier hs-type">Lit</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167194"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-265"></span><span id="litE"><span class="annot"><span class="annottext">litE :: forall (m :: * -&gt; *). Quote m =&gt; Lit -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#litE"><span class="hs-identifier hs-var hs-var">litE</span></a></span></span><span> </span><span id="local-6989586621679166450"><span class="annot"><span class="annottext">Lit
</span><a href="#local-6989586621679166450"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Lit -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#LitE"><span class="hs-identifier hs-var">LitE</span></a></span><span> </span><span class="annot"><span class="annottext">Lit
</span><a href="#local-6989586621679166450"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-266"></span><span>
</span><span id="line-267"></span><span id="local-6989586621679167192"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#appE"><span class="hs-identifier hs-type">appE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167192"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167192"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167192"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167192"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-268"></span><span id="appE"><span class="annot"><span class="annottext">appE :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Exp -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#appE"><span class="hs-identifier hs-var hs-var">appE</span></a></span></span><span> </span><span id="local-6989586621679166442"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166442"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679166441"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166441"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166440"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166440"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166442"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166439"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166439"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166441"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Exp -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#AppE"><span class="hs-identifier hs-var">AppE</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166440"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166439"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">)</span><span class="hs-special">}</span><span>
</span><span id="line-269"></span><span>
</span><span id="line-270"></span><span id="local-6989586621679167190"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#appTypeE"><span class="hs-identifier hs-type">appTypeE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167190"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167190"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167190"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167190"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-271"></span><span id="appTypeE"><span class="annot"><span class="annottext">appTypeE :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Type -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#appTypeE"><span class="hs-identifier hs-var hs-var">appTypeE</span></a></span></span><span> </span><span id="local-6989586621679166431"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166431"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679166430"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679166430"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166429"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166429"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166431"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166428"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679166428"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679166430"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Type -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#AppTypeE"><span class="hs-identifier hs-var">AppTypeE</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166429"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679166428"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-272"></span><span>
</span><span id="line-273"></span><span id="local-6989586621679167188"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#parensE"><span class="hs-identifier hs-type">parensE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167188"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167188"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167188"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-274"></span><span id="parensE"><span class="annot"><span class="annottext">parensE :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#parensE"><span class="hs-identifier hs-var hs-var">parensE</span></a></span></span><span> </span><span id="local-6989586621679166420"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166420"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166419"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166419"><span class="hs-identifier hs-var">x'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166420"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#ParensE"><span class="hs-identifier hs-var">ParensE</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166419"><span class="hs-identifier hs-var">x'</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-275"></span><span>
</span><span id="line-276"></span><span id="local-6989586621679167186"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#uInfixE"><span class="hs-identifier hs-type">uInfixE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167186"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167186"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167186"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167186"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167186"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-277"></span><span id="uInfixE"><span class="annot"><span class="annottext">uInfixE :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Exp -&gt; m Exp -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#uInfixE"><span class="hs-identifier hs-var hs-var">uInfixE</span></a></span></span><span> </span><span id="local-6989586621679166409"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166409"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679166408"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166408"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621679166407"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166407"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166406"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166406"><span class="hs-identifier hs-var">x'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166409"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166405"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166405"><span class="hs-identifier hs-var">s'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166408"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166404"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166404"><span class="hs-identifier hs-var">y'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166407"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">;</span><span>
</span><span id="line-278"></span><span>                     </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Exp -&gt; Exp -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#UInfixE"><span class="hs-identifier hs-var">UInfixE</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166406"><span class="hs-identifier hs-var">x'</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166405"><span class="hs-identifier hs-var">s'</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166404"><span class="hs-identifier hs-var">y'</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-279"></span><span>
</span><span id="line-280"></span><span id="local-6989586621679167184"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixE"><span class="hs-identifier hs-type">infixE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167184"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679167184"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167184"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679167184"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167184"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-281"></span><span id="infixE"><span class="annot"><span class="annottext">infixE :: forall (m :: * -&gt; *).
Quote m =&gt;
Maybe (m Exp) -&gt; m Exp -&gt; Maybe (m Exp) -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#infixE"><span class="hs-identifier hs-var hs-var">infixE</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621679166387"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166387"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679166386"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166386"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621679166385"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166385"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166384"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166384"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166387"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166383"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166383"><span class="hs-identifier hs-var">s'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166386"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166382"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166382"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166385"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">;</span><span>
</span><span id="line-282"></span><span>                                  </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe Exp -&gt; Exp -&gt; Maybe Exp -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#InfixE"><span class="hs-identifier hs-var">InfixE</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Maybe Exp
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166384"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166383"><span class="hs-identifier hs-var">s'</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Maybe Exp
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166382"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">}</span><span>
</span><span id="line-283"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixE"><span class="hs-identifier hs-var">infixE</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe (m Exp)
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>  </span><span id="local-6989586621679166380"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166380"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621679166379"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166379"><span class="hs-identifier hs-var">y</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166378"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166378"><span class="hs-identifier hs-var">s'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166380"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166377"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166377"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166379"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">;</span><span>
</span><span id="line-284"></span><span>                                  </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe Exp -&gt; Exp -&gt; Maybe Exp -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#InfixE"><span class="hs-identifier hs-var">InfixE</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Exp
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166378"><span class="hs-identifier hs-var">s'</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Maybe Exp
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166377"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">}</span><span>
</span><span id="line-285"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixE"><span class="hs-identifier hs-var">infixE</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621679166376"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166376"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679166375"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166375"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="annot"><span class="annottext">Maybe (m Exp)
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166374"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166374"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166376"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166373"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166373"><span class="hs-identifier hs-var">s'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166375"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">;</span><span>
</span><span id="line-286"></span><span>                                  </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe Exp -&gt; Exp -&gt; Maybe Exp -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#InfixE"><span class="hs-identifier hs-var">InfixE</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Maybe Exp
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166374"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166373"><span class="hs-identifier hs-var">s'</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Exp
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span class="hs-special">)</span><span class="hs-special">}</span><span>
</span><span id="line-287"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixE"><span class="hs-identifier hs-var">infixE</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe (m Exp)
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>  </span><span id="local-6989586621679166372"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166372"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="annot"><span class="annottext">Maybe (m Exp)
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166371"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166371"><span class="hs-identifier hs-var">s'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166372"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe Exp -&gt; Exp -&gt; Maybe Exp -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#InfixE"><span class="hs-identifier hs-var">InfixE</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Exp
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166371"><span class="hs-identifier hs-var">s'</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Exp
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-288"></span><span>
</span><span id="line-289"></span><span id="local-6989586621679166370"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixApp"><span class="hs-identifier hs-type">infixApp</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166370"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166370"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166370"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166370"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166370"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-290"></span><span id="infixApp"><span class="annot"><span class="annottext">infixApp :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Exp -&gt; m Exp -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#infixApp"><span class="hs-identifier hs-var hs-var">infixApp</span></a></span></span><span> </span><span id="local-6989586621679166367"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166367"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679166366"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166366"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span id="local-6989586621679166365"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166365"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (m Exp) -&gt; m Exp -&gt; Maybe (m Exp) -&gt; m Exp
forall (m :: * -&gt; *).
Quote m =&gt;
Maybe (m Exp) -&gt; m Exp -&gt; Maybe (m Exp) -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#infixE"><span class="hs-identifier hs-var">infixE</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m Exp -&gt; Maybe (m Exp)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166367"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166366"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m Exp -&gt; Maybe (m Exp)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166365"><span class="hs-identifier hs-var">z</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-291"></span><span id="local-6989586621679166364"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sectionL"><span class="hs-identifier hs-type">sectionL</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166364"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166364"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166364"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166364"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-292"></span><span id="sectionL"><span class="annot"><span class="annottext">sectionL :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Exp -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#sectionL"><span class="hs-identifier hs-var hs-var">sectionL</span></a></span></span><span> </span><span id="local-6989586621679166361"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166361"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679166360"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166360"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (m Exp) -&gt; m Exp -&gt; Maybe (m Exp) -&gt; m Exp
forall (m :: * -&gt; *).
Quote m =&gt;
Maybe (m Exp) -&gt; m Exp -&gt; Maybe (m Exp) -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#infixE"><span class="hs-identifier hs-var">infixE</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m Exp -&gt; Maybe (m Exp)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166361"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166360"><span class="hs-identifier hs-var">y</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe (m Exp)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-293"></span><span id="local-6989586621679166359"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sectionR"><span class="hs-identifier hs-type">sectionR</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166359"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166359"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166359"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166359"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-294"></span><span id="sectionR"><span class="annot"><span class="annottext">sectionR :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Exp -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#sectionR"><span class="hs-identifier hs-var hs-var">sectionR</span></a></span></span><span> </span><span id="local-6989586621679166356"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166356"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679166355"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166355"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (m Exp) -&gt; m Exp -&gt; Maybe (m Exp) -&gt; m Exp
forall (m :: * -&gt; *).
Quote m =&gt;
Maybe (m Exp) -&gt; m Exp -&gt; Maybe (m Exp) -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#infixE"><span class="hs-identifier hs-var">infixE</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe (m Exp)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166356"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m Exp -&gt; Maybe (m Exp)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166355"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-295"></span><span>
</span><span id="line-296"></span><span id="local-6989586621679167178"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#lamE"><span class="hs-identifier hs-type">lamE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167178"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167178"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167178"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167178"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-297"></span><span id="lamE"><span class="annot"><span class="annottext">lamE :: forall (m :: * -&gt; *). Quote m =&gt; [m Pat] -&gt; m Exp -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#lamE"><span class="hs-identifier hs-var hs-var">lamE</span></a></span></span><span> </span><span id="local-6989586621679166346"><span class="annot"><span class="annottext">[m Pat]
</span><a href="#local-6989586621679166346"><span class="hs-identifier hs-var">ps</span></a></span></span><span> </span><span id="local-6989586621679166345"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166345"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679166344"><span class="annot"><span class="annottext">[Pat]
</span><a href="#local-6989586621679166344"><span class="hs-identifier hs-var">ps'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Pat] -&gt; m [Pat]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Pat]
</span><a href="#local-6989586621679166346"><span class="hs-identifier hs-var">ps</span></a></span><span>
</span><span id="line-298"></span><span>               </span><span id="local-6989586621679166343"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166343"><span class="hs-identifier hs-var">e'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166345"><span class="hs-identifier hs-var">e</span></a></span><span>
</span><span id="line-299"></span><span>               </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Pat] -&gt; Exp -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#LamE"><span class="hs-identifier hs-var">LamE</span></a></span><span> </span><span class="annot"><span class="annottext">[Pat]
</span><a href="#local-6989586621679166344"><span class="hs-identifier hs-var">ps'</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166343"><span class="hs-identifier hs-var">e'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-300"></span><span>
</span><span id="line-301"></span><span class="hs-comment">-- | Single-arg lambda</span><span>
</span><span id="line-302"></span><span id="local-6989586621679167176"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#lam1E"><span class="hs-identifier hs-type">lam1E</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167176"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167176"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167176"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167176"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-303"></span><span id="lam1E"><span class="annot"><span class="annottext">lam1E :: forall (m :: * -&gt; *). Quote m =&gt; m Pat -&gt; m Exp -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#lam1E"><span class="hs-identifier hs-var hs-var">lam1E</span></a></span></span><span> </span><span id="local-6989586621679166338"><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166338"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679166337"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166337"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[m Pat] -&gt; m Exp -&gt; m Exp
forall (m :: * -&gt; *). Quote m =&gt; [m Pat] -&gt; m Exp -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#lamE"><span class="hs-identifier hs-var">lamE</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166338"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">]</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166337"><span class="hs-identifier hs-var">e</span></a></span><span>
</span><span id="line-304"></span><span>
</span><span id="line-305"></span><span id="local-6989586621679167174"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#lamCaseE"><span class="hs-identifier hs-type">lamCaseE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167174"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167174"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Match"><span class="hs-identifier hs-type">Match</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167174"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-306"></span><span id="lamCaseE"><span class="annot"><span class="annottext">lamCaseE :: forall (m :: * -&gt; *). Quote m =&gt; [m Match] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#lamCaseE"><span class="hs-identifier hs-var hs-var">lamCaseE</span></a></span></span><span> </span><span id="local-6989586621679166328"><span class="annot"><span class="annottext">[m Match]
</span><a href="#local-6989586621679166328"><span class="hs-identifier hs-var">ms</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Match] -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#LamCaseE"><span class="hs-identifier hs-var">LamCaseE</span></a></span><span> </span><span class="annot"><span class="annottext">([Match] -&gt; Exp) -&gt; m [Match] -&gt; m Exp
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[m Match] -&gt; m [Match]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Match]
</span><a href="#local-6989586621679166328"><span class="hs-identifier hs-var">ms</span></a></span><span>
</span><span id="line-307"></span><span>
</span><span id="line-308"></span><span id="local-6989586621679167169"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tupE"><span class="hs-identifier hs-type">tupE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167169"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679167169"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167169"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-309"></span><span id="tupE"><span class="annot"><span class="annottext">tupE :: forall (m :: * -&gt; *). Quote m =&gt; [Maybe (m Exp)] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#tupE"><span class="hs-identifier hs-var hs-var">tupE</span></a></span></span><span> </span><span id="local-6989586621679166315"><span class="annot"><span class="annottext">[Maybe (m Exp)]
</span><a href="#local-6989586621679166315"><span class="hs-identifier hs-var">es</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166314"><span class="annot"><span class="annottext">[Maybe Exp]
</span><a href="#local-6989586621679166314"><span class="hs-identifier hs-var">es1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Maybe (m Exp) -&gt; m (Maybe Exp))
-&gt; [Maybe (m Exp)] -&gt; m [Maybe Exp]
forall (t :: * -&gt; *) (f :: * -&gt; *) a b.
(Traversable t, Applicative f) =&gt;
(a -&gt; f b) -&gt; t a -&gt; f (t b)
</span><a href="../../base/src/Data.Traversable.html#traverse"><span class="hs-identifier hs-var">traverse</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe (m Exp) -&gt; m (Maybe Exp)
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[Maybe (m Exp)]
</span><a href="#local-6989586621679166315"><span class="hs-identifier hs-var">es</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Maybe Exp] -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#TupE"><span class="hs-identifier hs-var">TupE</span></a></span><span> </span><span class="annot"><span class="annottext">[Maybe Exp]
</span><a href="#local-6989586621679166314"><span class="hs-identifier hs-var">es1</span></a></span><span class="hs-special">)</span><span class="hs-special">}</span><span>
</span><span id="line-310"></span><span>
</span><span id="line-311"></span><span id="local-6989586621679166312"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unboxedTupE"><span class="hs-identifier hs-type">unboxedTupE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166312"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679166312"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166312"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-312"></span><span id="unboxedTupE"><span class="annot"><span class="annottext">unboxedTupE :: forall (m :: * -&gt; *). Quote m =&gt; [Maybe (m Exp)] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#unboxedTupE"><span class="hs-identifier hs-var hs-var">unboxedTupE</span></a></span></span><span> </span><span id="local-6989586621679166302"><span class="annot"><span class="annottext">[Maybe (m Exp)]
</span><a href="#local-6989586621679166302"><span class="hs-identifier hs-var">es</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166301"><span class="annot"><span class="annottext">[Maybe Exp]
</span><a href="#local-6989586621679166301"><span class="hs-identifier hs-var">es1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Maybe (m Exp) -&gt; m (Maybe Exp))
-&gt; [Maybe (m Exp)] -&gt; m [Maybe Exp]
forall (t :: * -&gt; *) (f :: * -&gt; *) a b.
(Traversable t, Applicative f) =&gt;
(a -&gt; f b) -&gt; t a -&gt; f (t b)
</span><a href="../../base/src/Data.Traversable.html#traverse"><span class="hs-identifier hs-var">traverse</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe (m Exp) -&gt; m (Maybe Exp)
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[Maybe (m Exp)]
</span><a href="#local-6989586621679166302"><span class="hs-identifier hs-var">es</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Maybe Exp] -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#UnboxedTupE"><span class="hs-identifier hs-var">UnboxedTupE</span></a></span><span> </span><span class="annot"><span class="annottext">[Maybe Exp]
</span><a href="#local-6989586621679166301"><span class="hs-identifier hs-var">es1</span></a></span><span class="hs-special">)</span><span class="hs-special">}</span><span>
</span><span id="line-313"></span><span>
</span><span id="line-314"></span><span id="local-6989586621679167166"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unboxedSumE"><span class="hs-identifier hs-type">unboxedSumE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167166"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167166"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#SumAlt"><span class="hs-identifier hs-type">SumAlt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#SumArity"><span class="hs-identifier hs-type">SumArity</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167166"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-315"></span><span id="unboxedSumE"><span class="annot"><span class="annottext">unboxedSumE :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; SumAlt -&gt; SumAlt -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#unboxedSumE"><span class="hs-identifier hs-var hs-var">unboxedSumE</span></a></span></span><span> </span><span id="local-6989586621679166294"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166294"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span id="local-6989586621679166293"><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679166293"><span class="hs-identifier hs-var">alt</span></a></span></span><span> </span><span id="local-6989586621679166292"><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679166292"><span class="hs-identifier hs-var">arity</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166291"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166291"><span class="hs-identifier hs-var">e1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166294"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; SumAlt -&gt; SumAlt -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#UnboxedSumE"><span class="hs-identifier hs-var">UnboxedSumE</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166291"><span class="hs-identifier hs-var">e1</span></a></span><span> </span><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679166293"><span class="hs-identifier hs-var">alt</span></a></span><span> </span><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679166292"><span class="hs-identifier hs-var">arity</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-316"></span><span>
</span><span id="line-317"></span><span id="local-6989586621679166289"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#condE"><span class="hs-identifier hs-type">condE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166289"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166289"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166289"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166289"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166289"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-318"></span><span id="condE"><span class="annot"><span class="annottext">condE :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Exp -&gt; m Exp -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#condE"><span class="hs-identifier hs-var hs-var">condE</span></a></span></span><span> </span><span id="local-6989586621679166281"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166281"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679166280"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166280"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span id="local-6989586621679166279"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166279"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>  </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166278"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166278"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166281"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166277"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166277"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166280"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166276"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166276"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166279"><span class="hs-identifier hs-var">z</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Exp -&gt; Exp -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#CondE"><span class="hs-identifier hs-var">CondE</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166278"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166277"><span class="hs-identifier hs-var">b</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166276"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">)</span><span class="hs-special">}</span><span>
</span><span id="line-319"></span><span>
</span><span id="line-320"></span><span id="local-6989586621679167163"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#multiIfE"><span class="hs-identifier hs-type">multiIfE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167163"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167163"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Guard"><span class="hs-identifier hs-type">Guard</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167163"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-321"></span><span id="multiIfE"><span class="annot"><span class="annottext">multiIfE :: forall (m :: * -&gt; *). Quote m =&gt; [m (Guard, Exp)] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#multiIfE"><span class="hs-identifier hs-var hs-var">multiIfE</span></a></span></span><span> </span><span id="local-6989586621679166267"><span class="annot"><span class="annottext">[m (Guard, Exp)]
</span><a href="#local-6989586621679166267"><span class="hs-identifier hs-var">alts</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[(Guard, Exp)] -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#MultiIfE"><span class="hs-identifier hs-var">MultiIfE</span></a></span><span> </span><span class="annot"><span class="annottext">([(Guard, Exp)] -&gt; Exp) -&gt; m [(Guard, Exp)] -&gt; m Exp
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[m (Guard, Exp)] -&gt; m [(Guard, Exp)]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m (Guard, Exp)]
</span><a href="#local-6989586621679166267"><span class="hs-identifier hs-var">alts</span></a></span><span>
</span><span id="line-322"></span><span>
</span><span id="line-323"></span><span id="local-6989586621679167161"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#letE"><span class="hs-identifier hs-type">letE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167161"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167161"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167161"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167161"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-324"></span><span id="letE"><span class="annot"><span class="annottext">letE :: forall (m :: * -&gt; *). Quote m =&gt; [m Dec] -&gt; m Exp -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#letE"><span class="hs-identifier hs-var hs-var">letE</span></a></span></span><span> </span><span id="local-6989586621679166257"><span class="annot"><span class="annottext">[m Dec]
</span><a href="#local-6989586621679166257"><span class="hs-identifier hs-var">ds</span></a></span></span><span> </span><span id="local-6989586621679166256"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166256"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166255"><span class="annot"><span class="annottext">[Dec]
</span><a href="#local-6989586621679166255"><span class="hs-identifier hs-var">ds2</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Dec] -&gt; m [Dec]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Dec]
</span><a href="#local-6989586621679166257"><span class="hs-identifier hs-var">ds</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166254"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166254"><span class="hs-identifier hs-var">e2</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166256"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Dec] -&gt; Exp -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#LetE"><span class="hs-identifier hs-var">LetE</span></a></span><span> </span><span class="annot"><span class="annottext">[Dec]
</span><a href="#local-6989586621679166255"><span class="hs-identifier hs-var">ds2</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166254"><span class="hs-identifier hs-var">e2</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-325"></span><span>
</span><span id="line-326"></span><span id="local-6989586621679167159"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#caseE"><span class="hs-identifier hs-type">caseE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167159"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167159"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167159"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Match"><span class="hs-identifier hs-type">Match</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167159"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-327"></span><span id="caseE"><span class="annot"><span class="annottext">caseE :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; [m Match] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#caseE"><span class="hs-identifier hs-var hs-var">caseE</span></a></span></span><span> </span><span id="local-6989586621679166244"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166244"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span id="local-6989586621679166243"><span class="annot"><span class="annottext">[m Match]
</span><a href="#local-6989586621679166243"><span class="hs-identifier hs-var">ms</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166242"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166242"><span class="hs-identifier hs-var">e1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166244"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166241"><span class="annot"><span class="annottext">[Match]
</span><a href="#local-6989586621679166241"><span class="hs-identifier hs-var">ms1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Match] -&gt; m [Match]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Match]
</span><a href="#local-6989586621679166243"><span class="hs-identifier hs-var">ms</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; [Match] -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#CaseE"><span class="hs-identifier hs-var">CaseE</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166242"><span class="hs-identifier hs-var">e1</span></a></span><span> </span><span class="annot"><span class="annottext">[Match]
</span><a href="#local-6989586621679166241"><span class="hs-identifier hs-var">ms1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-328"></span><span>
</span><span id="line-329"></span><span id="local-6989586621679167157"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#doE"><span class="hs-identifier hs-type">doE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167157"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#ModName"><span class="hs-identifier hs-type">ModName</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167157"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Stmt"><span class="hs-identifier hs-type">Stmt</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167157"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-330"></span><span id="doE"><span class="annot"><span class="annottext">doE :: forall (m :: * -&gt; *). Quote m =&gt; Maybe ModName -&gt; [m Stmt] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#doE"><span class="hs-identifier hs-var hs-var">doE</span></a></span></span><span> </span><span id="local-6989586621679166232"><span class="annot"><span class="annottext">Maybe ModName
</span><a href="#local-6989586621679166232"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span id="local-6989586621679166231"><span class="annot"><span class="annottext">[m Stmt]
</span><a href="#local-6989586621679166231"><span class="hs-identifier hs-var">ss</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166230"><span class="annot"><span class="annottext">[Stmt]
</span><a href="#local-6989586621679166230"><span class="hs-identifier hs-var">ss1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Stmt] -&gt; m [Stmt]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Stmt]
</span><a href="#local-6989586621679166231"><span class="hs-identifier hs-var">ss</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe ModName -&gt; [Stmt] -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#DoE"><span class="hs-identifier hs-var">DoE</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe ModName
</span><a href="#local-6989586621679166232"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">[Stmt]
</span><a href="#local-6989586621679166230"><span class="hs-identifier hs-var">ss1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-331"></span><span>
</span><span id="line-332"></span><span id="local-6989586621679166228"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#mdoE"><span class="hs-identifier hs-type">mdoE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166228"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#ModName"><span class="hs-identifier hs-type">ModName</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679166228"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Stmt"><span class="hs-identifier hs-type">Stmt</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166228"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-333"></span><span id="mdoE"><span class="annot"><span class="annottext">mdoE :: forall (m :: * -&gt; *). Quote m =&gt; Maybe ModName -&gt; [m Stmt] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#mdoE"><span class="hs-identifier hs-var hs-var">mdoE</span></a></span></span><span> </span><span id="local-6989586621679166220"><span class="annot"><span class="annottext">Maybe ModName
</span><a href="#local-6989586621679166220"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span id="local-6989586621679166219"><span class="annot"><span class="annottext">[m Stmt]
</span><a href="#local-6989586621679166219"><span class="hs-identifier hs-var">ss</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166218"><span class="annot"><span class="annottext">[Stmt]
</span><a href="#local-6989586621679166218"><span class="hs-identifier hs-var">ss1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Stmt] -&gt; m [Stmt]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Stmt]
</span><a href="#local-6989586621679166219"><span class="hs-identifier hs-var">ss</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe ModName -&gt; [Stmt] -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#MDoE"><span class="hs-identifier hs-var">MDoE</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe ModName
</span><a href="#local-6989586621679166220"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">[Stmt]
</span><a href="#local-6989586621679166218"><span class="hs-identifier hs-var">ss1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-334"></span><span>
</span><span id="line-335"></span><span id="local-6989586621679167154"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#compE"><span class="hs-identifier hs-type">compE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167154"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167154"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Stmt"><span class="hs-identifier hs-type">Stmt</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167154"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-336"></span><span id="compE"><span class="annot"><span class="annottext">compE :: forall (m :: * -&gt; *). Quote m =&gt; [m Stmt] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#compE"><span class="hs-identifier hs-var hs-var">compE</span></a></span></span><span> </span><span id="local-6989586621679166209"><span class="annot"><span class="annottext">[m Stmt]
</span><a href="#local-6989586621679166209"><span class="hs-identifier hs-var">ss</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166208"><span class="annot"><span class="annottext">[Stmt]
</span><a href="#local-6989586621679166208"><span class="hs-identifier hs-var">ss1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Stmt] -&gt; m [Stmt]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Stmt]
</span><a href="#local-6989586621679166209"><span class="hs-identifier hs-var">ss</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Stmt] -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#CompE"><span class="hs-identifier hs-var">CompE</span></a></span><span> </span><span class="annot"><span class="annottext">[Stmt]
</span><a href="#local-6989586621679166208"><span class="hs-identifier hs-var">ss1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-337"></span><span>
</span><span id="line-338"></span><span id="local-6989586621679167152"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#arithSeqE"><span class="hs-identifier hs-type">arithSeqE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167152"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167152"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Range"><span class="hs-identifier hs-type">Range</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167152"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-339"></span><span id="arithSeqE"><span class="annot"><span class="annottext">arithSeqE :: forall (m :: * -&gt; *). Quote m =&gt; m Range -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#arithSeqE"><span class="hs-identifier hs-var hs-var">arithSeqE</span></a></span></span><span> </span><span id="local-6989586621679166200"><span class="annot"><span class="annottext">m Range
</span><a href="#local-6989586621679166200"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166199"><span class="annot"><span class="annottext">Range
</span><a href="#local-6989586621679166199"><span class="hs-identifier hs-var">r'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Range
</span><a href="#local-6989586621679166200"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Range -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#ArithSeqE"><span class="hs-identifier hs-var">ArithSeqE</span></a></span><span> </span><span class="annot"><span class="annottext">Range
</span><a href="#local-6989586621679166199"><span class="hs-identifier hs-var">r'</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-340"></span><span>
</span><span id="line-341"></span><span id="local-6989586621679167150"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#listE"><span class="hs-identifier hs-type">listE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167150"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167150"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167150"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-342"></span><span id="listE"><span class="annot"><span class="annottext">listE :: forall (m :: * -&gt; *). Quote m =&gt; [m Exp] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#listE"><span class="hs-identifier hs-var hs-var">listE</span></a></span></span><span> </span><span id="local-6989586621679166190"><span class="annot"><span class="annottext">[m Exp]
</span><a href="#local-6989586621679166190"><span class="hs-identifier hs-var">es</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166189"><span class="annot"><span class="annottext">[Exp]
</span><a href="#local-6989586621679166189"><span class="hs-identifier hs-var">es1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Exp] -&gt; m [Exp]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Exp]
</span><a href="#local-6989586621679166190"><span class="hs-identifier hs-var">es</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Exp] -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#ListE"><span class="hs-identifier hs-var">ListE</span></a></span><span> </span><span class="annot"><span class="annottext">[Exp]
</span><a href="#local-6989586621679166189"><span class="hs-identifier hs-var">es1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-343"></span><span>
</span><span id="line-344"></span><span id="local-6989586621679166187"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sigE"><span class="hs-identifier hs-type">sigE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166187"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166187"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166187"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166187"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-345"></span><span id="sigE"><span class="annot"><span class="annottext">sigE :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Type -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#sigE"><span class="hs-identifier hs-var hs-var">sigE</span></a></span></span><span> </span><span id="local-6989586621679166180"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166180"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span id="local-6989586621679166179"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679166179"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166178"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166178"><span class="hs-identifier hs-var">e1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166180"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166177"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679166177"><span class="hs-identifier hs-var">t1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679166179"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Type -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#SigE"><span class="hs-identifier hs-var">SigE</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166178"><span class="hs-identifier hs-var">e1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679166177"><span class="hs-identifier hs-var">t1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-346"></span><span>
</span><span id="line-347"></span><span id="local-6989586621679167147"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#recConE"><span class="hs-identifier hs-type">recConE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167147"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167147"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span class="hs-special">,</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167147"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-348"></span><span id="recConE"><span class="annot"><span class="annottext">recConE :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; [m (Name, Exp)] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#recConE"><span class="hs-identifier hs-var hs-var">recConE</span></a></span></span><span> </span><span id="local-6989586621679166168"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166168"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span id="local-6989586621679166167"><span class="annot"><span class="annottext">[m (Name, Exp)]
</span><a href="#local-6989586621679166167"><span class="hs-identifier hs-var">fs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166166"><span class="annot"><span class="annottext">[(Name, Exp)]
</span><a href="#local-6989586621679166166"><span class="hs-identifier hs-var">flds</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m (Name, Exp)] -&gt; m [(Name, Exp)]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m (Name, Exp)]
</span><a href="#local-6989586621679166167"><span class="hs-identifier hs-var">fs</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; [(Name, Exp)] -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#RecConE"><span class="hs-identifier hs-var">RecConE</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166168"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">[(Name, Exp)]
</span><a href="#local-6989586621679166166"><span class="hs-identifier hs-var">flds</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-349"></span><span>
</span><span id="line-350"></span><span id="local-6989586621679167145"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#recUpdE"><span class="hs-identifier hs-type">recUpdE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167145"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167145"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167145"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span class="hs-special">,</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167145"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-351"></span><span id="recUpdE"><span class="annot"><span class="annottext">recUpdE :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; [m (Name, Exp)] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#recUpdE"><span class="hs-identifier hs-var hs-var">recUpdE</span></a></span></span><span> </span><span id="local-6989586621679166156"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166156"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span id="local-6989586621679166155"><span class="annot"><span class="annottext">[m (Name, Exp)]
</span><a href="#local-6989586621679166155"><span class="hs-identifier hs-var">fs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166154"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166154"><span class="hs-identifier hs-var">e1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166156"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166153"><span class="annot"><span class="annottext">[(Name, Exp)]
</span><a href="#local-6989586621679166153"><span class="hs-identifier hs-var">flds</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m (Name, Exp)] -&gt; m [(Name, Exp)]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m (Name, Exp)]
</span><a href="#local-6989586621679166155"><span class="hs-identifier hs-var">fs</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; [(Name, Exp)] -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#RecUpdE"><span class="hs-identifier hs-var">RecUpdE</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166154"><span class="hs-identifier hs-var">e1</span></a></span><span> </span><span class="annot"><span class="annottext">[(Name, Exp)]
</span><a href="#local-6989586621679166153"><span class="hs-identifier hs-var">flds</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-352"></span><span>
</span><span id="line-353"></span><span id="local-6989586621679166151"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#stringE"><span class="hs-identifier hs-type">stringE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166151"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166151"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-354"></span><span id="stringE"><span class="annot"><span class="annottext">stringE :: forall (m :: * -&gt; *). Quote m =&gt; String -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#stringE"><span class="hs-identifier hs-var hs-var">stringE</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Lit -&gt; m Exp
forall (m :: * -&gt; *). Quote m =&gt; Lit -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#litE"><span class="hs-identifier hs-var">litE</span></a></span><span> </span><span class="annot"><span class="annottext">(Lit -&gt; m Exp) -&gt; (String -&gt; Lit) -&gt; String -&gt; m Exp
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; Lit
</span><a href="Language.Haskell.TH.Lib.Internal.html#stringL"><span class="hs-identifier hs-var">stringL</span></a></span><span>
</span><span id="line-355"></span><span>
</span><span id="line-356"></span><span id="local-6989586621679167139"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fieldExp"><span class="hs-identifier hs-type">fieldExp</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167139"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167139"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167139"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-357"></span><span id="fieldExp"><span class="annot"><span class="annottext">fieldExp :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Exp -&gt; m (Name, Exp)
</span><a href="Language.Haskell.TH.Lib.Internal.html#fieldExp"><span class="hs-identifier hs-var hs-var">fieldExp</span></a></span></span><span> </span><span id="local-6989586621679166141"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166141"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621679166140"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166140"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166139"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166139"><span class="hs-identifier hs-var">e'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166140"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(Name, Exp) -&gt; m (Name, Exp)
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166141"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166139"><span class="hs-identifier hs-var">e'</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-358"></span><span>
</span><span id="line-359"></span><span class="hs-comment">-- | @staticE x = [| static x |]@</span><span>
</span><span id="line-360"></span><span id="local-6989586621679166138"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#staticE"><span class="hs-identifier hs-type">staticE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166138"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166138"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166138"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-361"></span><span id="staticE"><span class="annot"><span class="annottext">staticE :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#staticE"><span class="hs-identifier hs-var hs-var">staticE</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Exp -&gt; Exp) -&gt; m Exp -&gt; m Exp
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">Exp -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#StaticE"><span class="hs-identifier hs-var">StaticE</span></a></span><span>
</span><span id="line-362"></span><span>
</span><span id="line-363"></span><span id="local-6989586621679166131"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unboundVarE"><span class="hs-identifier hs-type">unboundVarE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166131"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166131"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-364"></span><span id="unboundVarE"><span class="annot"><span class="annottext">unboundVarE :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#unboundVarE"><span class="hs-identifier hs-var hs-var">unboundVarE</span></a></span></span><span> </span><span id="local-6989586621679166126"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166126"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#UnboundVarE"><span class="hs-identifier hs-var">UnboundVarE</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166126"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-365"></span><span>
</span><span id="line-366"></span><span id="local-6989586621679166124"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#labelE"><span class="hs-identifier hs-type">labelE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166124"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166124"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-367"></span><span id="labelE"><span class="annot"><span class="annottext">labelE :: forall (m :: * -&gt; *). Quote m =&gt; String -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#labelE"><span class="hs-identifier hs-var hs-var">labelE</span></a></span></span><span> </span><span id="local-6989586621679166119"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679166119"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#LabelE"><span class="hs-identifier hs-var">LabelE</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679166119"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-368"></span><span>
</span><span id="line-369"></span><span id="local-6989586621679166117"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#implicitParamVarE"><span class="hs-identifier hs-type">implicitParamVarE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166117"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166117"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-370"></span><span id="implicitParamVarE"><span class="annot"><span class="annottext">implicitParamVarE :: forall (m :: * -&gt; *). Quote m =&gt; String -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#implicitParamVarE"><span class="hs-identifier hs-var hs-var">implicitParamVarE</span></a></span></span><span> </span><span id="local-6989586621679166112"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679166112"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#ImplicitParamVarE"><span class="hs-identifier hs-var">ImplicitParamVarE</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679166112"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-371"></span><span>
</span><span id="line-372"></span><span class="hs-comment">-- ** 'arithSeqE' Shortcuts</span><span>
</span><span id="line-373"></span><span id="local-6989586621679166110"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fromE"><span class="hs-identifier hs-type">fromE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166110"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166110"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166110"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-374"></span><span id="fromE"><span class="annot"><span class="annottext">fromE :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#fromE"><span class="hs-identifier hs-var hs-var">fromE</span></a></span></span><span> </span><span id="local-6989586621679166104"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166104"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166103"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166103"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166104"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Range -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#ArithSeqE"><span class="hs-identifier hs-var">ArithSeqE</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Range
</span><a href="Language.Haskell.TH.Syntax.html#FromR"><span class="hs-identifier hs-var">FromR</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166103"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-375"></span><span>
</span><span id="line-376"></span><span id="local-6989586621679166102"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fromThenE"><span class="hs-identifier hs-type">fromThenE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166102"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166102"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166102"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166102"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-377"></span><span id="fromThenE"><span class="annot"><span class="annottext">fromThenE :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Exp -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#fromThenE"><span class="hs-identifier hs-var hs-var">fromThenE</span></a></span></span><span> </span><span id="local-6989586621679166095"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166095"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679166094"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166094"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166093"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166093"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166095"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166092"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166092"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166094"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Range -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#ArithSeqE"><span class="hs-identifier hs-var">ArithSeqE</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Exp -&gt; Range
</span><a href="Language.Haskell.TH.Syntax.html#FromThenR"><span class="hs-identifier hs-var">FromThenR</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166093"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166092"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-378"></span><span>
</span><span id="line-379"></span><span id="local-6989586621679166091"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fromToE"><span class="hs-identifier hs-type">fromToE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166091"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166091"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166091"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166091"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-380"></span><span id="fromToE"><span class="annot"><span class="annottext">fromToE :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Exp -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#fromToE"><span class="hs-identifier hs-var hs-var">fromToE</span></a></span></span><span> </span><span id="local-6989586621679166084"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166084"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679166083"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166083"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166082"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166082"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166084"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166081"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166081"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166083"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Range -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#ArithSeqE"><span class="hs-identifier hs-var">ArithSeqE</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Exp -&gt; Range
</span><a href="Language.Haskell.TH.Syntax.html#FromToR"><span class="hs-identifier hs-var">FromToR</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166082"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166081"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-381"></span><span>
</span><span id="line-382"></span><span id="local-6989586621679166080"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fromThenToE"><span class="hs-identifier hs-type">fromThenToE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166080"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166080"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166080"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166080"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166080"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-383"></span><span id="fromThenToE"><span class="annot"><span class="annottext">fromThenToE :: forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Exp -&gt; m Exp -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#fromThenToE"><span class="hs-identifier hs-var hs-var">fromThenToE</span></a></span></span><span> </span><span id="local-6989586621679166072"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166072"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679166071"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166071"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span id="local-6989586621679166070"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166070"><span class="hs-identifier hs-var">z</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166069"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166069"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166072"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166068"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166068"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166071"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166067"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166067"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679166070"><span class="hs-identifier hs-var">z</span></a></span><span class="hs-special">;</span><span>
</span><span id="line-384"></span><span>                         </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Range -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#ArithSeqE"><span class="hs-identifier hs-var">ArithSeqE</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Exp -&gt; Exp -&gt; Exp -&gt; Range
</span><a href="Language.Haskell.TH.Syntax.html#FromThenToR"><span class="hs-identifier hs-var">FromThenToR</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166069"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166068"><span class="hs-identifier hs-var">b</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679166067"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-385"></span><span>
</span><span id="line-386"></span><span>
</span><span id="line-387"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-388"></span><span class="hs-comment">-- *   Dec</span><span>
</span><span id="line-389"></span><span>
</span><span id="line-390"></span><span id="local-6989586621679167126"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#valD"><span class="hs-identifier hs-type">valD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167126"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167126"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167126"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Body"><span class="hs-identifier hs-type">Body</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167126"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167126"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-391"></span><span id="valD"><span class="annot"><span class="annottext">valD :: forall (m :: * -&gt; *).
Quote m =&gt;
m Pat -&gt; m Body -&gt; [m Dec] -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#valD"><span class="hs-identifier hs-var hs-var">valD</span></a></span></span><span> </span><span id="local-6989586621679166057"><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166057"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679166056"><span class="annot"><span class="annottext">m Body
</span><a href="#local-6989586621679166056"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span id="local-6989586621679166055"><span class="annot"><span class="annottext">[m Dec]
</span><a href="#local-6989586621679166055"><span class="hs-identifier hs-var">ds</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-392"></span><span>  </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166054"><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166054"><span class="hs-identifier hs-var">p'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679166057"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-393"></span><span>     </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166053"><span class="annot"><span class="annottext">[Dec]
</span><a href="#local-6989586621679166053"><span class="hs-identifier hs-var">ds'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Dec] -&gt; m [Dec]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Dec]
</span><a href="#local-6989586621679166055"><span class="hs-identifier hs-var">ds</span></a></span><span>
</span><span id="line-394"></span><span>     </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166052"><span class="annot"><span class="annottext">Body
</span><a href="#local-6989586621679166052"><span class="hs-identifier hs-var">b'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Body
</span><a href="#local-6989586621679166056"><span class="hs-identifier hs-var">b</span></a></span><span>
</span><span id="line-395"></span><span>     </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Pat -&gt; Body -&gt; [Dec] -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#ValD"><span class="hs-identifier hs-var">ValD</span></a></span><span> </span><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679166054"><span class="hs-identifier hs-var">p'</span></a></span><span> </span><span class="annot"><span class="annottext">Body
</span><a href="#local-6989586621679166052"><span class="hs-identifier hs-var">b'</span></a></span><span> </span><span class="annot"><span class="annottext">[Dec]
</span><a href="#local-6989586621679166053"><span class="hs-identifier hs-var">ds'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-396"></span><span>     </span><span class="hs-special">}</span><span>
</span><span id="line-397"></span><span>
</span><span id="line-398"></span><span id="local-6989586621679167124"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#funD"><span class="hs-identifier hs-type">funD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167124"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167124"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Clause"><span class="hs-identifier hs-type">Clause</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167124"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-399"></span><span id="funD"><span class="annot"><span class="annottext">funD :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; [m Clause] -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#funD"><span class="hs-identifier hs-var hs-var">funD</span></a></span></span><span> </span><span id="local-6989586621679166043"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166043"><span class="hs-identifier hs-var">nm</span></a></span></span><span> </span><span id="local-6989586621679166042"><span class="annot"><span class="annottext">[m Clause]
</span><a href="#local-6989586621679166042"><span class="hs-identifier hs-var">cs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-400"></span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166041"><span class="annot"><span class="annottext">[Clause]
</span><a href="#local-6989586621679166041"><span class="hs-identifier hs-var">cs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Clause] -&gt; m [Clause]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Clause]
</span><a href="#local-6989586621679166042"><span class="hs-identifier hs-var">cs</span></a></span><span>
</span><span id="line-401"></span><span>    </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; [Clause] -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#FunD"><span class="hs-identifier hs-var">FunD</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166043"><span class="hs-identifier hs-var">nm</span></a></span><span> </span><span class="annot"><span class="annottext">[Clause]
</span><a href="#local-6989586621679166041"><span class="hs-identifier hs-var">cs1</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-402"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-403"></span><span>
</span><span id="line-404"></span><span id="local-6989586621679167122"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tySynD"><span class="hs-identifier hs-type">tySynD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167122"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167122"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167122"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167122"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-405"></span><span id="tySynD"><span class="annot"><span class="annottext">tySynD :: forall (m :: * -&gt; *).
Quote m =&gt;
Name -&gt; [m (TyVarBndr ())] -&gt; m Type -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#tySynD"><span class="hs-identifier hs-var hs-var">tySynD</span></a></span></span><span> </span><span id="local-6989586621679166031"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166031"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621679166030"><span class="annot"><span class="annottext">[m (TyVarBndr ())]
</span><a href="#local-6989586621679166030"><span class="hs-identifier hs-var">tvs</span></a></span></span><span> </span><span id="local-6989586621679166029"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679166029"><span class="hs-identifier hs-var">rhs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-406"></span><span>  </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679166028"><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679166028"><span class="hs-identifier hs-var">tvs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())] -&gt; m [TyVarBndr ()]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())]
</span><a href="#local-6989586621679166030"><span class="hs-identifier hs-var">tvs</span></a></span><span>
</span><span id="line-407"></span><span>     </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679166027"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679166027"><span class="hs-identifier hs-var">rhs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679166029"><span class="hs-identifier hs-var">rhs</span></a></span><span>
</span><span id="line-408"></span><span>     </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; [TyVarBndr ()] -&gt; Type -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#TySynD"><span class="hs-identifier hs-var">TySynD</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166031"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679166028"><span class="hs-identifier hs-var">tvs1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679166027"><span class="hs-identifier hs-var">rhs1</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-409"></span><span>     </span><span class="hs-special">}</span><span>
</span><span id="line-410"></span><span>
</span><span id="line-411"></span><span id="local-6989586621679167119"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#dataD"><span class="hs-identifier hs-type">dataD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167119"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167119"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167119"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679167119"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167119"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-412"></span><span>      </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167119"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivClause"><span class="hs-identifier hs-type">DerivClause</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167119"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-413"></span><span id="dataD"><span class="annot"><span class="annottext">dataD :: forall (m :: * -&gt; *).
Quote m =&gt;
m Cxt
-&gt; Name
-&gt; [m (TyVarBndr ())]
-&gt; Maybe (m Type)
-&gt; [m Con]
-&gt; [m DerivClause]
-&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#dataD"><span class="hs-identifier hs-var hs-var">dataD</span></a></span></span><span> </span><span id="local-6989586621679166008"><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679166008"><span class="hs-identifier hs-var">ctxt</span></a></span></span><span> </span><span id="local-6989586621679166007"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166007"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621679166006"><span class="annot"><span class="annottext">[m (TyVarBndr ())]
</span><a href="#local-6989586621679166006"><span class="hs-identifier hs-var">tvs</span></a></span></span><span> </span><span id="local-6989586621679166005"><span class="annot"><span class="annottext">Maybe (m Type)
</span><a href="#local-6989586621679166005"><span class="hs-identifier hs-var">ksig</span></a></span></span><span> </span><span id="local-6989586621679166004"><span class="annot"><span class="annottext">[m Con]
</span><a href="#local-6989586621679166004"><span class="hs-identifier hs-var">cons</span></a></span></span><span> </span><span id="local-6989586621679166003"><span class="annot"><span class="annottext">[m DerivClause]
</span><a href="#local-6989586621679166003"><span class="hs-identifier hs-var">derivs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-414"></span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-415"></span><span>    </span><span id="local-6989586621679166002"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679166002"><span class="hs-identifier hs-var">ctxt1</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679166008"><span class="hs-identifier hs-var">ctxt</span></a></span><span>
</span><span id="line-416"></span><span>    </span><span id="local-6989586621679166001"><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679166001"><span class="hs-identifier hs-var">tvs1</span></a></span></span><span>    </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())] -&gt; m [TyVarBndr ()]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())]
</span><a href="#local-6989586621679166006"><span class="hs-identifier hs-var">tvs</span></a></span><span>
</span><span id="line-417"></span><span>    </span><span id="local-6989586621679166000"><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679166000"><span class="hs-identifier hs-var">ksig1</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe (m Type) -&gt; m (Maybe Type)
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe (m Type)
</span><a href="#local-6989586621679166005"><span class="hs-identifier hs-var">ksig</span></a></span><span>
</span><span id="line-418"></span><span>    </span><span id="local-6989586621679165999"><span class="annot"><span class="annottext">[Con]
</span><a href="#local-6989586621679165999"><span class="hs-identifier hs-var">cons1</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Con] -&gt; m [Con]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Con]
</span><a href="#local-6989586621679166004"><span class="hs-identifier hs-var">cons</span></a></span><span>
</span><span id="line-419"></span><span>    </span><span id="local-6989586621679165998"><span class="annot"><span class="annottext">[DerivClause]
</span><a href="#local-6989586621679165998"><span class="hs-identifier hs-var">derivs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m DerivClause] -&gt; m [DerivClause]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m DerivClause]
</span><a href="#local-6989586621679166003"><span class="hs-identifier hs-var">derivs</span></a></span><span>
</span><span id="line-420"></span><span>    </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Cxt
-&gt; Name
-&gt; [TyVarBndr ()]
-&gt; Maybe Type
-&gt; [Con]
-&gt; [DerivClause]
-&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#DataD"><span class="hs-identifier hs-var">DataD</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679166002"><span class="hs-identifier hs-var">ctxt1</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679166007"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679166001"><span class="hs-identifier hs-var">tvs1</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679166000"><span class="hs-identifier hs-var">ksig1</span></a></span><span> </span><span class="annot"><span class="annottext">[Con]
</span><a href="#local-6989586621679165999"><span class="hs-identifier hs-var">cons1</span></a></span><span> </span><span class="annot"><span class="annottext">[DerivClause]
</span><a href="#local-6989586621679165998"><span class="hs-identifier hs-var">derivs1</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-421"></span><span>
</span><span id="line-422"></span><span id="local-6989586621679167116"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#newtypeD"><span class="hs-identifier hs-type">newtypeD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167116"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167116"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167116"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679167116"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167116"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span><span>
</span><span id="line-423"></span><span>         </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167116"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivClause"><span class="hs-identifier hs-type">DerivClause</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167116"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-424"></span><span id="newtypeD"><span class="annot"><span class="annottext">newtypeD :: forall (m :: * -&gt; *).
Quote m =&gt;
m Cxt
-&gt; Name
-&gt; [m (TyVarBndr ())]
-&gt; Maybe (m Type)
-&gt; m Con
-&gt; [m DerivClause]
-&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#newtypeD"><span class="hs-identifier hs-var hs-var">newtypeD</span></a></span></span><span> </span><span id="local-6989586621679165981"><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679165981"><span class="hs-identifier hs-var">ctxt</span></a></span></span><span> </span><span id="local-6989586621679165980"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165980"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621679165979"><span class="annot"><span class="annottext">[m (TyVarBndr ())]
</span><a href="#local-6989586621679165979"><span class="hs-identifier hs-var">tvs</span></a></span></span><span> </span><span id="local-6989586621679165978"><span class="annot"><span class="annottext">Maybe (m Type)
</span><a href="#local-6989586621679165978"><span class="hs-identifier hs-var">ksig</span></a></span></span><span> </span><span id="local-6989586621679165977"><span class="annot"><span class="annottext">m Con
</span><a href="#local-6989586621679165977"><span class="hs-identifier hs-var">con</span></a></span></span><span> </span><span id="local-6989586621679165976"><span class="annot"><span class="annottext">[m DerivClause]
</span><a href="#local-6989586621679165976"><span class="hs-identifier hs-var">derivs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-425"></span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-426"></span><span>    </span><span id="local-6989586621679165975"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165975"><span class="hs-identifier hs-var">ctxt1</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679165981"><span class="hs-identifier hs-var">ctxt</span></a></span><span>
</span><span id="line-427"></span><span>    </span><span id="local-6989586621679165974"><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679165974"><span class="hs-identifier hs-var">tvs1</span></a></span></span><span>    </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())] -&gt; m [TyVarBndr ()]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())]
</span><a href="#local-6989586621679165979"><span class="hs-identifier hs-var">tvs</span></a></span><span>
</span><span id="line-428"></span><span>    </span><span id="local-6989586621679165973"><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679165973"><span class="hs-identifier hs-var">ksig1</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe (m Type) -&gt; m (Maybe Type)
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe (m Type)
</span><a href="#local-6989586621679165978"><span class="hs-identifier hs-var">ksig</span></a></span><span>
</span><span id="line-429"></span><span>    </span><span id="local-6989586621679165972"><span class="annot"><span class="annottext">Con
</span><a href="#local-6989586621679165972"><span class="hs-identifier hs-var">con1</span></a></span></span><span>    </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Con
</span><a href="#local-6989586621679165977"><span class="hs-identifier hs-var">con</span></a></span><span>
</span><span id="line-430"></span><span>    </span><span id="local-6989586621679165971"><span class="annot"><span class="annottext">[DerivClause]
</span><a href="#local-6989586621679165971"><span class="hs-identifier hs-var">derivs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m DerivClause] -&gt; m [DerivClause]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m DerivClause]
</span><a href="#local-6989586621679165976"><span class="hs-identifier hs-var">derivs</span></a></span><span>
</span><span id="line-431"></span><span>    </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Cxt
-&gt; Name
-&gt; [TyVarBndr ()]
-&gt; Maybe Type
-&gt; Con
-&gt; [DerivClause]
-&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#NewtypeD"><span class="hs-identifier hs-var">NewtypeD</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165975"><span class="hs-identifier hs-var">ctxt1</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165980"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679165974"><span class="hs-identifier hs-var">tvs1</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679165973"><span class="hs-identifier hs-var">ksig1</span></a></span><span> </span><span class="annot"><span class="annottext">Con
</span><a href="#local-6989586621679165972"><span class="hs-identifier hs-var">con1</span></a></span><span> </span><span class="annot"><span class="annottext">[DerivClause]
</span><a href="#local-6989586621679165971"><span class="hs-identifier hs-var">derivs1</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-432"></span><span>
</span><span id="line-433"></span><span id="local-6989586621679167114"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#classD"><span class="hs-identifier hs-type">classD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167114"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167114"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167114"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FunDep"><span class="hs-identifier hs-type">FunDep</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167114"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167114"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-434"></span><span id="classD"><span class="annot"><span class="annottext">classD :: forall (m :: * -&gt; *).
Quote m =&gt;
m Cxt -&gt; Name -&gt; [m (TyVarBndr ())] -&gt; [FunDep] -&gt; [m Dec] -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#classD"><span class="hs-identifier hs-var hs-var">classD</span></a></span></span><span> </span><span id="local-6989586621679165958"><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679165958"><span class="hs-identifier hs-var">ctxt</span></a></span></span><span> </span><span id="local-6989586621679165957"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165957"><span class="hs-identifier hs-var">cls</span></a></span></span><span> </span><span id="local-6989586621679165956"><span class="annot"><span class="annottext">[m (TyVarBndr ())]
</span><a href="#local-6989586621679165956"><span class="hs-identifier hs-var">tvs</span></a></span></span><span> </span><span id="local-6989586621679165955"><span class="annot"><span class="annottext">[FunDep]
</span><a href="#local-6989586621679165955"><span class="hs-identifier hs-var">fds</span></a></span></span><span> </span><span id="local-6989586621679165954"><span class="annot"><span class="annottext">[m Dec]
</span><a href="#local-6989586621679165954"><span class="hs-identifier hs-var">decs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-435"></span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-436"></span><span>    </span><span id="local-6989586621679165953"><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679165953"><span class="hs-identifier hs-var">tvs1</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())] -&gt; m [TyVarBndr ()]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())]
</span><a href="#local-6989586621679165956"><span class="hs-identifier hs-var">tvs</span></a></span><span>
</span><span id="line-437"></span><span>    </span><span id="local-6989586621679165952"><span class="annot"><span class="annottext">[Dec]
</span><a href="#local-6989586621679165952"><span class="hs-identifier hs-var">decs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Dec] -&gt; m [Dec]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Dec]
</span><a href="#local-6989586621679165954"><span class="hs-identifier hs-var">decs</span></a></span><span>
</span><span id="line-438"></span><span>    </span><span id="local-6989586621679165951"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165951"><span class="hs-identifier hs-var">ctxt1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679165958"><span class="hs-identifier hs-var">ctxt</span></a></span><span>
</span><span id="line-439"></span><span>    </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt -&gt; Name -&gt; [TyVarBndr ()] -&gt; [FunDep] -&gt; [Dec] -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#ClassD"><span class="hs-identifier hs-var">ClassD</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165951"><span class="hs-identifier hs-var">ctxt1</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165957"><span class="hs-identifier hs-var">cls</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679165953"><span class="hs-identifier hs-var">tvs1</span></a></span><span> </span><span class="annot"><span class="annottext">[FunDep]
</span><a href="#local-6989586621679165955"><span class="hs-identifier hs-var">fds</span></a></span><span> </span><span class="annot"><span class="annottext">[Dec]
</span><a href="#local-6989586621679165952"><span class="hs-identifier hs-var">decs1</span></a></span><span>
</span><span id="line-440"></span><span>
</span><span id="line-441"></span><span id="local-6989586621679167109"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#instanceD"><span class="hs-identifier hs-type">instanceD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167109"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167109"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167109"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167109"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167109"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-442"></span><span id="instanceD"><span class="annot"><span class="annottext">instanceD :: forall (m :: * -&gt; *).
Quote m =&gt;
m Cxt -&gt; m Type -&gt; [m Dec] -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#instanceD"><span class="hs-identifier hs-var hs-var">instanceD</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe Overlap -&gt; m Cxt -&gt; m Type -&gt; [m Dec] -&gt; m Dec
forall (m :: * -&gt; *).
Quote m =&gt;
Maybe Overlap -&gt; m Cxt -&gt; m Type -&gt; [m Dec] -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#instanceWithOverlapD"><span class="hs-identifier hs-var">instanceWithOverlapD</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Overlap
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-443"></span><span>
</span><span id="line-444"></span><span id="local-6989586621679167107"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#instanceWithOverlapD"><span class="hs-identifier hs-type">instanceWithOverlapD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167107"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Overlap"><span class="hs-identifier hs-type">Overlap</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167107"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167107"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167107"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167107"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-445"></span><span id="instanceWithOverlapD"><span class="annot"><span class="annottext">instanceWithOverlapD :: forall (m :: * -&gt; *).
Quote m =&gt;
Maybe Overlap -&gt; m Cxt -&gt; m Type -&gt; [m Dec] -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#instanceWithOverlapD"><span class="hs-identifier hs-var hs-var">instanceWithOverlapD</span></a></span></span><span> </span><span id="local-6989586621679165937"><span class="annot"><span class="annottext">Maybe Overlap
</span><a href="#local-6989586621679165937"><span class="hs-identifier hs-var">o</span></a></span></span><span> </span><span id="local-6989586621679165936"><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679165936"><span class="hs-identifier hs-var">ctxt</span></a></span></span><span> </span><span id="local-6989586621679165935"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165935"><span class="hs-identifier hs-var">ty</span></a></span></span><span> </span><span id="local-6989586621679165934"><span class="annot"><span class="annottext">[m Dec]
</span><a href="#local-6989586621679165934"><span class="hs-identifier hs-var">decs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-446"></span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-447"></span><span>    </span><span id="local-6989586621679165933"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165933"><span class="hs-identifier hs-var">ctxt1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679165936"><span class="hs-identifier hs-var">ctxt</span></a></span><span>
</span><span id="line-448"></span><span>    </span><span id="local-6989586621679165932"><span class="annot"><span class="annottext">[Dec]
</span><a href="#local-6989586621679165932"><span class="hs-identifier hs-var">decs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Dec] -&gt; m [Dec]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Dec]
</span><a href="#local-6989586621679165934"><span class="hs-identifier hs-var">decs</span></a></span><span>
</span><span id="line-449"></span><span>    </span><span id="local-6989586621679165931"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165931"><span class="hs-identifier hs-var">ty1</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165935"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-450"></span><span>    </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Overlap -&gt; Cxt -&gt; Type -&gt; [Dec] -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#InstanceD"><span class="hs-identifier hs-var">InstanceD</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Overlap
</span><a href="#local-6989586621679165937"><span class="hs-identifier hs-var">o</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165933"><span class="hs-identifier hs-var">ctxt1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165931"><span class="hs-identifier hs-var">ty1</span></a></span><span> </span><span class="annot"><span class="annottext">[Dec]
</span><a href="#local-6989586621679165932"><span class="hs-identifier hs-var">decs1</span></a></span><span>
</span><span id="line-451"></span><span>
</span><span id="line-452"></span><span>
</span><span id="line-453"></span><span>
</span><span id="line-454"></span><span id="local-6989586621679167105"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sigD"><span class="hs-identifier hs-type">sigD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167105"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167105"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167105"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-455"></span><span id="sigD"><span class="annot"><span class="annottext">sigD :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Type -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#sigD"><span class="hs-identifier hs-var hs-var">sigD</span></a></span></span><span> </span><span id="local-6989586621679165925"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165925"><span class="hs-identifier hs-var">fun</span></a></span></span><span> </span><span id="local-6989586621679165924"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165924"><span class="hs-identifier hs-var">ty</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Type -&gt; Dec) -&gt; m Type -&gt; m Dec
forall (f :: * -&gt; *) a b. Applicative f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#liftA"><span class="hs-identifier hs-var">liftA</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; Type -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#SigD"><span class="hs-identifier hs-var">SigD</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165925"><span class="hs-identifier hs-var">fun</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(m Type -&gt; m Dec) -&gt; m Type -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165924"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-456"></span><span>
</span><span id="line-457"></span><span id="local-6989586621679165922"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#kiSigD"><span class="hs-identifier hs-type">kiSigD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165922"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165922"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165922"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-458"></span><span id="kiSigD"><span class="annot"><span class="annottext">kiSigD :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Type -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#kiSigD"><span class="hs-identifier hs-var hs-var">kiSigD</span></a></span></span><span> </span><span id="local-6989586621679165917"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165917"><span class="hs-identifier hs-var">fun</span></a></span></span><span> </span><span id="local-6989586621679165916"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165916"><span class="hs-identifier hs-var">ki</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Type -&gt; Dec) -&gt; m Type -&gt; m Dec
forall (f :: * -&gt; *) a b. Applicative f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#liftA"><span class="hs-identifier hs-var">liftA</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; Type -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#KiSigD"><span class="hs-identifier hs-var">KiSigD</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165917"><span class="hs-identifier hs-var">fun</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(m Type -&gt; m Dec) -&gt; m Type -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165916"><span class="hs-identifier hs-var">ki</span></a></span><span>
</span><span id="line-459"></span><span>
</span><span id="line-460"></span><span id="local-6989586621679167099"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#forImpD"><span class="hs-identifier hs-type">forImpD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167099"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Callconv"><span class="hs-identifier hs-type">Callconv</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Safety"><span class="hs-identifier hs-type">Safety</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167099"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167099"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-461"></span><span id="forImpD"><span class="annot"><span class="annottext">forImpD :: forall (m :: * -&gt; *).
Quote m =&gt;
Callconv -&gt; Safety -&gt; String -&gt; Name -&gt; m Type -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#forImpD"><span class="hs-identifier hs-var hs-var">forImpD</span></a></span></span><span> </span><span id="local-6989586621679165909"><span class="annot"><span class="annottext">Callconv
</span><a href="#local-6989586621679165909"><span class="hs-identifier hs-var">cc</span></a></span></span><span> </span><span id="local-6989586621679165908"><span class="annot"><span class="annottext">Safety
</span><a href="#local-6989586621679165908"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621679165907"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679165907"><span class="hs-identifier hs-var">str</span></a></span></span><span> </span><span id="local-6989586621679165906"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165906"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679165905"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165905"><span class="hs-identifier hs-var">ty</span></a></span></span><span>
</span><span id="line-462"></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679165904"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165904"><span class="hs-identifier hs-var">ty'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165905"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-463"></span><span>      </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Foreign -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#ForeignD"><span class="hs-identifier hs-var">ForeignD</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Callconv -&gt; Safety -&gt; String -&gt; Name -&gt; Type -&gt; Foreign
</span><a href="Language.Haskell.TH.Syntax.html#ImportF"><span class="hs-identifier hs-var">ImportF</span></a></span><span> </span><span class="annot"><span class="annottext">Callconv
</span><a href="#local-6989586621679165909"><span class="hs-identifier hs-var">cc</span></a></span><span> </span><span class="annot"><span class="annottext">Safety
</span><a href="#local-6989586621679165908"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679165907"><span class="hs-identifier hs-var">str</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165906"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165904"><span class="hs-identifier hs-var">ty'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-464"></span><span>
</span><span id="line-465"></span><span id="local-6989586621679167094"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixLD"><span class="hs-identifier hs-type">infixLD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167094"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167094"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-466"></span><span id="infixLD"><span class="annot"><span class="annottext">infixLD :: forall (m :: * -&gt; *). Quote m =&gt; SumAlt -&gt; Name -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#infixLD"><span class="hs-identifier hs-var hs-var">infixLD</span></a></span></span><span> </span><span id="local-6989586621679165897"><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679165897"><span class="hs-identifier hs-var">prec</span></a></span></span><span> </span><span id="local-6989586621679165896"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165896"><span class="hs-identifier hs-var">nm</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Fixity -&gt; Name -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#InfixD"><span class="hs-identifier hs-var">InfixD</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SumAlt -&gt; FixityDirection -&gt; Fixity
</span><a href="Language.Haskell.TH.Syntax.html#Fixity"><span class="hs-identifier hs-var">Fixity</span></a></span><span> </span><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679165897"><span class="hs-identifier hs-var">prec</span></a></span><span> </span><span class="annot"><span class="annottext">FixityDirection
</span><a href="Language.Haskell.TH.Syntax.html#InfixL"><span class="hs-identifier hs-var">InfixL</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165896"><span class="hs-identifier hs-var">nm</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-467"></span><span>
</span><span id="line-468"></span><span id="local-6989586621679165892"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixRD"><span class="hs-identifier hs-type">infixRD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165892"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165892"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-469"></span><span id="infixRD"><span class="annot"><span class="annottext">infixRD :: forall (m :: * -&gt; *). Quote m =&gt; SumAlt -&gt; Name -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#infixRD"><span class="hs-identifier hs-var hs-var">infixRD</span></a></span></span><span> </span><span id="local-6989586621679165887"><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679165887"><span class="hs-identifier hs-var">prec</span></a></span></span><span> </span><span id="local-6989586621679165886"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165886"><span class="hs-identifier hs-var">nm</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Fixity -&gt; Name -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#InfixD"><span class="hs-identifier hs-var">InfixD</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SumAlt -&gt; FixityDirection -&gt; Fixity
</span><a href="Language.Haskell.TH.Syntax.html#Fixity"><span class="hs-identifier hs-var">Fixity</span></a></span><span> </span><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679165887"><span class="hs-identifier hs-var">prec</span></a></span><span> </span><span class="annot"><span class="annottext">FixityDirection
</span><a href="Language.Haskell.TH.Syntax.html#InfixR"><span class="hs-identifier hs-var">InfixR</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165886"><span class="hs-identifier hs-var">nm</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-470"></span><span>
</span><span id="line-471"></span><span id="local-6989586621679165884"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixND"><span class="hs-identifier hs-type">infixND</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165884"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165884"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-472"></span><span id="infixND"><span class="annot"><span class="annottext">infixND :: forall (m :: * -&gt; *). Quote m =&gt; SumAlt -&gt; Name -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#infixND"><span class="hs-identifier hs-var hs-var">infixND</span></a></span></span><span> </span><span id="local-6989586621679165879"><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679165879"><span class="hs-identifier hs-var">prec</span></a></span></span><span> </span><span id="local-6989586621679165878"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165878"><span class="hs-identifier hs-var">nm</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Fixity -&gt; Name -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#InfixD"><span class="hs-identifier hs-var">InfixD</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SumAlt -&gt; FixityDirection -&gt; Fixity
</span><a href="Language.Haskell.TH.Syntax.html#Fixity"><span class="hs-identifier hs-var">Fixity</span></a></span><span> </span><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679165879"><span class="hs-identifier hs-var">prec</span></a></span><span> </span><span class="annot"><span class="annottext">FixityDirection
</span><a href="Language.Haskell.TH.Syntax.html#InfixN"><span class="hs-identifier hs-var">InfixN</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165878"><span class="hs-identifier hs-var">nm</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-473"></span><span>
</span><span id="line-474"></span><span id="local-6989586621679167088"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#pragInlD"><span class="hs-identifier hs-type">pragInlD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167088"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Inline"><span class="hs-identifier hs-type">Inline</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#RuleMatch"><span class="hs-identifier hs-type">RuleMatch</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Phases"><span class="hs-identifier hs-type">Phases</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167088"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-475"></span><span id="pragInlD"><span class="annot"><span class="annottext">pragInlD :: forall (m :: * -&gt; *).
Quote m =&gt;
Name -&gt; Inline -&gt; RuleMatch -&gt; Phases -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#pragInlD"><span class="hs-identifier hs-var hs-var">pragInlD</span></a></span></span><span> </span><span id="local-6989586621679165872"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165872"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span id="local-6989586621679165871"><span class="annot"><span class="annottext">Inline
</span><a href="#local-6989586621679165871"><span class="hs-identifier hs-var">inline</span></a></span></span><span> </span><span id="local-6989586621679165870"><span class="annot"><span class="annottext">RuleMatch
</span><a href="#local-6989586621679165870"><span class="hs-identifier hs-var">rm</span></a></span></span><span> </span><span id="local-6989586621679165869"><span class="annot"><span class="annottext">Phases
</span><a href="#local-6989586621679165869"><span class="hs-identifier hs-var">phases</span></a></span></span><span>
</span><span id="line-476"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Pragma -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#PragmaD"><span class="hs-identifier hs-var">PragmaD</span></a></span><span> </span><span class="annot"><span class="annottext">(Pragma -&gt; Dec) -&gt; Pragma -&gt; Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Name -&gt; Inline -&gt; RuleMatch -&gt; Phases -&gt; Pragma
</span><a href="Language.Haskell.TH.Syntax.html#InlineP"><span class="hs-identifier hs-var">InlineP</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165872"><span class="hs-identifier hs-var">name</span></a></span><span> </span><span class="annot"><span class="annottext">Inline
</span><a href="#local-6989586621679165871"><span class="hs-identifier hs-var">inline</span></a></span><span> </span><span class="annot"><span class="annottext">RuleMatch
</span><a href="#local-6989586621679165870"><span class="hs-identifier hs-var">rm</span></a></span><span> </span><span class="annot"><span class="annottext">Phases
</span><a href="#local-6989586621679165869"><span class="hs-identifier hs-var">phases</span></a></span><span>
</span><span id="line-477"></span><span>
</span><span id="line-478"></span><span id="local-6989586621679167082"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#pragSpecD"><span class="hs-identifier hs-type">pragSpecD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167082"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167082"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Phases"><span class="hs-identifier hs-type">Phases</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167082"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-479"></span><span id="pragSpecD"><span class="annot"><span class="annottext">pragSpecD :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Type -&gt; Phases -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#pragSpecD"><span class="hs-identifier hs-var hs-var">pragSpecD</span></a></span></span><span> </span><span id="local-6989586621679165861"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165861"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679165860"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165860"><span class="hs-identifier hs-var">ty</span></a></span></span><span> </span><span id="local-6989586621679165859"><span class="annot"><span class="annottext">Phases
</span><a href="#local-6989586621679165859"><span class="hs-identifier hs-var">phases</span></a></span></span><span>
</span><span id="line-480"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-481"></span><span>      </span><span id="local-6989586621679165858"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165858"><span class="hs-identifier hs-var">ty1</span></a></span></span><span>    </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165860"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-482"></span><span>      </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Pragma -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#PragmaD"><span class="hs-identifier hs-var">PragmaD</span></a></span><span> </span><span class="annot"><span class="annottext">(Pragma -&gt; Dec) -&gt; Pragma -&gt; Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Name -&gt; Type -&gt; Maybe Inline -&gt; Phases -&gt; Pragma
</span><a href="Language.Haskell.TH.Syntax.html#SpecialiseP"><span class="hs-identifier hs-var">SpecialiseP</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165861"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165858"><span class="hs-identifier hs-var">ty1</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Inline
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="annot"><span class="annottext">Phases
</span><a href="#local-6989586621679165859"><span class="hs-identifier hs-var">phases</span></a></span><span>
</span><span id="line-483"></span><span>
</span><span id="line-484"></span><span id="local-6989586621679167080"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#pragSpecInlD"><span class="hs-identifier hs-type">pragSpecInlD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167080"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167080"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Inline"><span class="hs-identifier hs-type">Inline</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Phases"><span class="hs-identifier hs-type">Phases</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167080"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-485"></span><span id="pragSpecInlD"><span class="annot"><span class="annottext">pragSpecInlD :: forall (m :: * -&gt; *).
Quote m =&gt;
Name -&gt; m Type -&gt; Inline -&gt; Phases -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#pragSpecInlD"><span class="hs-identifier hs-var hs-var">pragSpecInlD</span></a></span></span><span> </span><span id="local-6989586621679165851"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165851"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679165850"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165850"><span class="hs-identifier hs-var">ty</span></a></span></span><span> </span><span id="local-6989586621679165849"><span class="annot"><span class="annottext">Inline
</span><a href="#local-6989586621679165849"><span class="hs-identifier hs-var">inline</span></a></span></span><span> </span><span id="local-6989586621679165848"><span class="annot"><span class="annottext">Phases
</span><a href="#local-6989586621679165848"><span class="hs-identifier hs-var">phases</span></a></span></span><span>
</span><span id="line-486"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-487"></span><span>      </span><span id="local-6989586621679165847"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165847"><span class="hs-identifier hs-var">ty1</span></a></span></span><span>    </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165850"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-488"></span><span>      </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Pragma -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#PragmaD"><span class="hs-identifier hs-var">PragmaD</span></a></span><span> </span><span class="annot"><span class="annottext">(Pragma -&gt; Dec) -&gt; Pragma -&gt; Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Name -&gt; Type -&gt; Maybe Inline -&gt; Phases -&gt; Pragma
</span><a href="Language.Haskell.TH.Syntax.html#SpecialiseP"><span class="hs-identifier hs-var">SpecialiseP</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165851"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165847"><span class="hs-identifier hs-var">ty1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Inline -&gt; Maybe Inline
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Inline
</span><a href="#local-6989586621679165849"><span class="hs-identifier hs-var">inline</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Phases
</span><a href="#local-6989586621679165848"><span class="hs-identifier hs-var">phases</span></a></span><span>
</span><span id="line-489"></span><span>
</span><span id="line-490"></span><span id="local-6989586621679167078"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#pragSpecInstD"><span class="hs-identifier hs-type">pragSpecInstD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167078"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167078"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167078"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-491"></span><span id="pragSpecInstD"><span class="annot"><span class="annottext">pragSpecInstD :: forall (m :: * -&gt; *). Quote m =&gt; m Type -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#pragSpecInstD"><span class="hs-identifier hs-var hs-var">pragSpecInstD</span></a></span></span><span> </span><span id="local-6989586621679165841"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165841"><span class="hs-identifier hs-var">ty</span></a></span></span><span>
</span><span id="line-492"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-493"></span><span>      </span><span id="local-6989586621679165840"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165840"><span class="hs-identifier hs-var">ty1</span></a></span></span><span>    </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165841"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-494"></span><span>      </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Pragma -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#PragmaD"><span class="hs-identifier hs-var">PragmaD</span></a></span><span> </span><span class="annot"><span class="annottext">(Pragma -&gt; Dec) -&gt; Pragma -&gt; Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Pragma
</span><a href="Language.Haskell.TH.Syntax.html#SpecialiseInstP"><span class="hs-identifier hs-var">SpecialiseInstP</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165840"><span class="hs-identifier hs-var">ty1</span></a></span><span>
</span><span id="line-495"></span><span>
</span><span id="line-496"></span><span id="local-6989586621679167076"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#pragRuleD"><span class="hs-identifier hs-type">pragRuleD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167076"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167076"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167076"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#RuleBndr"><span class="hs-identifier hs-type">RuleBndr</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167076"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167076"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span>
</span><span id="line-497"></span><span>          </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Phases"><span class="hs-identifier hs-type">Phases</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167076"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-498"></span><span id="pragRuleD"><span class="annot"><span class="annottext">pragRuleD :: forall (m :: * -&gt; *).
Quote m =&gt;
String
-&gt; Maybe [m (TyVarBndr ())]
-&gt; [m RuleBndr]
-&gt; m Exp
-&gt; m Exp
-&gt; Phases
-&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#pragRuleD"><span class="hs-identifier hs-var hs-var">pragRuleD</span></a></span></span><span> </span><span id="local-6989586621679165824"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679165824"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679165823"><span class="annot"><span class="annottext">Maybe [m (TyVarBndr ())]
</span><a href="#local-6989586621679165823"><span class="hs-identifier hs-var">ty_bndrs</span></a></span></span><span> </span><span id="local-6989586621679165822"><span class="annot"><span class="annottext">[m RuleBndr]
</span><a href="#local-6989586621679165822"><span class="hs-identifier hs-var">tm_bndrs</span></a></span></span><span> </span><span id="local-6989586621679165821"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679165821"><span class="hs-identifier hs-var">lhs</span></a></span></span><span> </span><span id="local-6989586621679165820"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679165820"><span class="hs-identifier hs-var">rhs</span></a></span></span><span> </span><span id="local-6989586621679165819"><span class="annot"><span class="annottext">Phases
</span><a href="#local-6989586621679165819"><span class="hs-identifier hs-var">phases</span></a></span></span><span>
</span><span id="line-499"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-500"></span><span>      </span><span id="local-6989586621679165818"><span class="annot"><span class="annottext">Maybe [TyVarBndr ()]
</span><a href="#local-6989586621679165818"><span class="hs-identifier hs-var">ty_bndrs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">([m (TyVarBndr ())] -&gt; m [TyVarBndr ()])
-&gt; Maybe [m (TyVarBndr ())] -&gt; m (Maybe [TyVarBndr ()])
forall (t :: * -&gt; *) (f :: * -&gt; *) a b.
(Traversable t, Applicative f) =&gt;
(a -&gt; f b) -&gt; t a -&gt; f (t b)
</span><a href="../../base/src/Data.Traversable.html#traverse"><span class="hs-identifier hs-var">traverse</span></a></span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())] -&gt; m [TyVarBndr ()]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe [m (TyVarBndr ())]
</span><a href="#local-6989586621679165823"><span class="hs-identifier hs-var">ty_bndrs</span></a></span><span>
</span><span id="line-501"></span><span>      </span><span id="local-6989586621679165817"><span class="annot"><span class="annottext">[RuleBndr]
</span><a href="#local-6989586621679165817"><span class="hs-identifier hs-var">tm_bndrs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m RuleBndr] -&gt; m [RuleBndr]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m RuleBndr]
</span><a href="#local-6989586621679165822"><span class="hs-identifier hs-var">tm_bndrs</span></a></span><span>
</span><span id="line-502"></span><span>      </span><span id="local-6989586621679165816"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679165816"><span class="hs-identifier hs-var">lhs1</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679165821"><span class="hs-identifier hs-var">lhs</span></a></span><span>
</span><span id="line-503"></span><span>      </span><span id="local-6989586621679165815"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679165815"><span class="hs-identifier hs-var">rhs1</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679165820"><span class="hs-identifier hs-var">rhs</span></a></span><span>
</span><span id="line-504"></span><span>      </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Pragma -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#PragmaD"><span class="hs-identifier hs-var">PragmaD</span></a></span><span> </span><span class="annot"><span class="annottext">(Pragma -&gt; Dec) -&gt; Pragma -&gt; Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">String
-&gt; Maybe [TyVarBndr ()]
-&gt; [RuleBndr]
-&gt; Exp
-&gt; Exp
-&gt; Phases
-&gt; Pragma
</span><a href="Language.Haskell.TH.Syntax.html#RuleP"><span class="hs-identifier hs-var">RuleP</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679165824"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe [TyVarBndr ()]
</span><a href="#local-6989586621679165818"><span class="hs-identifier hs-var">ty_bndrs1</span></a></span><span> </span><span class="annot"><span class="annottext">[RuleBndr]
</span><a href="#local-6989586621679165817"><span class="hs-identifier hs-var">tm_bndrs1</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679165816"><span class="hs-identifier hs-var">lhs1</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679165815"><span class="hs-identifier hs-var">rhs1</span></a></span><span> </span><span class="annot"><span class="annottext">Phases
</span><a href="#local-6989586621679165819"><span class="hs-identifier hs-var">phases</span></a></span><span>
</span><span id="line-505"></span><span>
</span><span id="line-506"></span><span id="local-6989586621679167074"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#pragAnnD"><span class="hs-identifier hs-type">pragAnnD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167074"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#AnnTarget"><span class="hs-identifier hs-type">AnnTarget</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167074"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167074"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-507"></span><span id="pragAnnD"><span class="annot"><span class="annottext">pragAnnD :: forall (m :: * -&gt; *). Quote m =&gt; AnnTarget -&gt; m Exp -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#pragAnnD"><span class="hs-identifier hs-var hs-var">pragAnnD</span></a></span></span><span> </span><span id="local-6989586621679165808"><span class="annot"><span class="annottext">AnnTarget
</span><a href="#local-6989586621679165808"><span class="hs-identifier hs-var">target</span></a></span></span><span> </span><span id="local-6989586621679165807"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679165807"><span class="hs-identifier hs-var">expr</span></a></span></span><span>
</span><span id="line-508"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-509"></span><span>      </span><span id="local-6989586621679165806"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679165806"><span class="hs-identifier hs-var">exp1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679165807"><span class="hs-identifier hs-var">expr</span></a></span><span>
</span><span id="line-510"></span><span>      </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Pragma -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#PragmaD"><span class="hs-identifier hs-var">PragmaD</span></a></span><span> </span><span class="annot"><span class="annottext">(Pragma -&gt; Dec) -&gt; Pragma -&gt; Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">AnnTarget -&gt; Exp -&gt; Pragma
</span><a href="Language.Haskell.TH.Syntax.html#AnnP"><span class="hs-identifier hs-var">AnnP</span></a></span><span> </span><span class="annot"><span class="annottext">AnnTarget
</span><a href="#local-6989586621679165808"><span class="hs-identifier hs-var">target</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679165806"><span class="hs-identifier hs-var">exp1</span></a></span><span>
</span><span id="line-511"></span><span>
</span><span id="line-512"></span><span id="local-6989586621679167071"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#pragLineD"><span class="hs-identifier hs-type">pragLineD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167071"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167071"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-513"></span><span id="pragLineD"><span class="annot"><span class="annottext">pragLineD :: forall (m :: * -&gt; *). Quote m =&gt; SumAlt -&gt; String -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#pragLineD"><span class="hs-identifier hs-var hs-var">pragLineD</span></a></span></span><span> </span><span id="local-6989586621679165799"><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679165799"><span class="hs-identifier hs-var">line</span></a></span></span><span> </span><span id="local-6989586621679165798"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679165798"><span class="hs-identifier hs-var">file</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Pragma -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#PragmaD"><span class="hs-identifier hs-var">PragmaD</span></a></span><span> </span><span class="annot"><span class="annottext">(Pragma -&gt; Dec) -&gt; Pragma -&gt; Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">SumAlt -&gt; String -&gt; Pragma
</span><a href="Language.Haskell.TH.Syntax.html#LineP"><span class="hs-identifier hs-var">LineP</span></a></span><span> </span><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679165799"><span class="hs-identifier hs-var">line</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679165798"><span class="hs-identifier hs-var">file</span></a></span><span>
</span><span id="line-514"></span><span>
</span><span id="line-515"></span><span id="local-6989586621679167069"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#pragCompleteD"><span class="hs-identifier hs-type">pragCompleteD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167069"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167069"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-516"></span><span id="pragCompleteD"><span class="annot"><span class="annottext">pragCompleteD :: forall (m :: * -&gt; *). Quote m =&gt; [Name] -&gt; Maybe Name -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#pragCompleteD"><span class="hs-identifier hs-var hs-var">pragCompleteD</span></a></span></span><span> </span><span id="local-6989586621679165792"><span class="annot"><span class="annottext">[Name]
</span><a href="#local-6989586621679165792"><span class="hs-identifier hs-var">cls</span></a></span></span><span> </span><span id="local-6989586621679165791"><span class="annot"><span class="annottext">Maybe Name
</span><a href="#local-6989586621679165791"><span class="hs-identifier hs-var">mty</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Pragma -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#PragmaD"><span class="hs-identifier hs-var">PragmaD</span></a></span><span> </span><span class="annot"><span class="annottext">(Pragma -&gt; Dec) -&gt; Pragma -&gt; Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">[Name] -&gt; Maybe Name -&gt; Pragma
</span><a href="Language.Haskell.TH.Syntax.html#CompleteP"><span class="hs-identifier hs-var">CompleteP</span></a></span><span> </span><span class="annot"><span class="annottext">[Name]
</span><a href="#local-6989586621679165792"><span class="hs-identifier hs-var">cls</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Name
</span><a href="#local-6989586621679165791"><span class="hs-identifier hs-var">mty</span></a></span><span>
</span><span id="line-517"></span><span>
</span><span id="line-518"></span><span id="local-6989586621679167067"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#dataInstD"><span class="hs-identifier hs-type">dataInstD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167067"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167067"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167067"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">]</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167067"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679167067"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167067"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-519"></span><span>          </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167067"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivClause"><span class="hs-identifier hs-type">DerivClause</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167067"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-520"></span><span id="dataInstD"><span class="annot"><span class="annottext">dataInstD :: forall (m :: * -&gt; *).
Quote m =&gt;
m Cxt
-&gt; Maybe [m (TyVarBndr ())]
-&gt; m Type
-&gt; Maybe (m Type)
-&gt; [m Con]
-&gt; [m DerivClause]
-&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#dataInstD"><span class="hs-identifier hs-var hs-var">dataInstD</span></a></span></span><span> </span><span id="local-6989586621679165769"><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679165769"><span class="hs-identifier hs-var">ctxt</span></a></span></span><span> </span><span id="local-6989586621679165768"><span class="annot"><span class="annottext">Maybe [m (TyVarBndr ())]
</span><a href="#local-6989586621679165768"><span class="hs-identifier hs-var">mb_bndrs</span></a></span></span><span> </span><span id="local-6989586621679165767"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165767"><span class="hs-identifier hs-var">ty</span></a></span></span><span> </span><span id="local-6989586621679165766"><span class="annot"><span class="annottext">Maybe (m Type)
</span><a href="#local-6989586621679165766"><span class="hs-identifier hs-var">ksig</span></a></span></span><span> </span><span id="local-6989586621679165765"><span class="annot"><span class="annottext">[m Con]
</span><a href="#local-6989586621679165765"><span class="hs-identifier hs-var">cons</span></a></span></span><span> </span><span id="local-6989586621679165764"><span class="annot"><span class="annottext">[m DerivClause]
</span><a href="#local-6989586621679165764"><span class="hs-identifier hs-var">derivs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-521"></span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-522"></span><span>    </span><span id="local-6989586621679165763"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165763"><span class="hs-identifier hs-var">ctxt1</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679165769"><span class="hs-identifier hs-var">ctxt</span></a></span><span>
</span><span id="line-523"></span><span>    </span><span id="local-6989586621679165762"><span class="annot"><span class="annottext">Maybe [TyVarBndr ()]
</span><a href="#local-6989586621679165762"><span class="hs-identifier hs-var">mb_bndrs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">([m (TyVarBndr ())] -&gt; m [TyVarBndr ()])
-&gt; Maybe [m (TyVarBndr ())] -&gt; m (Maybe [TyVarBndr ()])
forall (t :: * -&gt; *) (f :: * -&gt; *) a b.
(Traversable t, Applicative f) =&gt;
(a -&gt; f b) -&gt; t a -&gt; f (t b)
</span><a href="../../base/src/Data.Traversable.html#traverse"><span class="hs-identifier hs-var">traverse</span></a></span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())] -&gt; m [TyVarBndr ()]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe [m (TyVarBndr ())]
</span><a href="#local-6989586621679165768"><span class="hs-identifier hs-var">mb_bndrs</span></a></span><span>
</span><span id="line-524"></span><span>    </span><span id="local-6989586621679165761"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165761"><span class="hs-identifier hs-var">ty1</span></a></span></span><span>    </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165767"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-525"></span><span>    </span><span id="local-6989586621679165760"><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679165760"><span class="hs-identifier hs-var">ksig1</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe (m Type) -&gt; m (Maybe Type)
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe (m Type)
</span><a href="#local-6989586621679165766"><span class="hs-identifier hs-var">ksig</span></a></span><span>
</span><span id="line-526"></span><span>    </span><span id="local-6989586621679165759"><span class="annot"><span class="annottext">[Con]
</span><a href="#local-6989586621679165759"><span class="hs-identifier hs-var">cons1</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Con] -&gt; m [Con]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Con]
</span><a href="#local-6989586621679165765"><span class="hs-identifier hs-var">cons</span></a></span><span>
</span><span id="line-527"></span><span>    </span><span id="local-6989586621679165758"><span class="annot"><span class="annottext">[DerivClause]
</span><a href="#local-6989586621679165758"><span class="hs-identifier hs-var">derivs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m DerivClause] -&gt; m [DerivClause]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m DerivClause]
</span><a href="#local-6989586621679165764"><span class="hs-identifier hs-var">derivs</span></a></span><span>
</span><span id="line-528"></span><span>    </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Cxt
-&gt; Maybe [TyVarBndr ()]
-&gt; Type
-&gt; Maybe Type
-&gt; [Con]
-&gt; [DerivClause]
-&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#DataInstD"><span class="hs-identifier hs-var">DataInstD</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165763"><span class="hs-identifier hs-var">ctxt1</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe [TyVarBndr ()]
</span><a href="#local-6989586621679165762"><span class="hs-identifier hs-var">mb_bndrs1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165761"><span class="hs-identifier hs-var">ty1</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679165760"><span class="hs-identifier hs-var">ksig1</span></a></span><span> </span><span class="annot"><span class="annottext">[Con]
</span><a href="#local-6989586621679165759"><span class="hs-identifier hs-var">cons1</span></a></span><span> </span><span class="annot"><span class="annottext">[DerivClause]
</span><a href="#local-6989586621679165758"><span class="hs-identifier hs-var">derivs1</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-529"></span><span>
</span><span id="line-530"></span><span id="local-6989586621679167065"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#newtypeInstD"><span class="hs-identifier hs-type">newtypeInstD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167065"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167065"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167065"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">]</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167065"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679167065"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167065"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span><span>
</span><span id="line-531"></span><span>             </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167065"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivClause"><span class="hs-identifier hs-type">DerivClause</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167065"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-532"></span><span id="newtypeInstD"><span class="annot"><span class="annottext">newtypeInstD :: forall (m :: * -&gt; *).
Quote m =&gt;
m Cxt
-&gt; Maybe [m (TyVarBndr ())]
-&gt; m Type
-&gt; Maybe (m Type)
-&gt; m Con
-&gt; [m DerivClause]
-&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#newtypeInstD"><span class="hs-identifier hs-var hs-var">newtypeInstD</span></a></span></span><span> </span><span id="local-6989586621679165738"><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679165738"><span class="hs-identifier hs-var">ctxt</span></a></span></span><span> </span><span id="local-6989586621679165737"><span class="annot"><span class="annottext">Maybe [m (TyVarBndr ())]
</span><a href="#local-6989586621679165737"><span class="hs-identifier hs-var">mb_bndrs</span></a></span></span><span> </span><span id="local-6989586621679165736"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165736"><span class="hs-identifier hs-var">ty</span></a></span></span><span> </span><span id="local-6989586621679165735"><span class="annot"><span class="annottext">Maybe (m Type)
</span><a href="#local-6989586621679165735"><span class="hs-identifier hs-var">ksig</span></a></span></span><span> </span><span id="local-6989586621679165734"><span class="annot"><span class="annottext">m Con
</span><a href="#local-6989586621679165734"><span class="hs-identifier hs-var">con</span></a></span></span><span> </span><span id="local-6989586621679165733"><span class="annot"><span class="annottext">[m DerivClause]
</span><a href="#local-6989586621679165733"><span class="hs-identifier hs-var">derivs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-533"></span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-534"></span><span>    </span><span id="local-6989586621679165732"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165732"><span class="hs-identifier hs-var">ctxt1</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679165738"><span class="hs-identifier hs-var">ctxt</span></a></span><span>
</span><span id="line-535"></span><span>    </span><span id="local-6989586621679165731"><span class="annot"><span class="annottext">Maybe [TyVarBndr ()]
</span><a href="#local-6989586621679165731"><span class="hs-identifier hs-var">mb_bndrs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">([m (TyVarBndr ())] -&gt; m [TyVarBndr ()])
-&gt; Maybe [m (TyVarBndr ())] -&gt; m (Maybe [TyVarBndr ()])
forall (t :: * -&gt; *) (f :: * -&gt; *) a b.
(Traversable t, Applicative f) =&gt;
(a -&gt; f b) -&gt; t a -&gt; f (t b)
</span><a href="../../base/src/Data.Traversable.html#traverse"><span class="hs-identifier hs-var">traverse</span></a></span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())] -&gt; m [TyVarBndr ()]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe [m (TyVarBndr ())]
</span><a href="#local-6989586621679165737"><span class="hs-identifier hs-var">mb_bndrs</span></a></span><span>
</span><span id="line-536"></span><span>    </span><span id="local-6989586621679165730"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165730"><span class="hs-identifier hs-var">ty1</span></a></span></span><span>    </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165736"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-537"></span><span>    </span><span id="local-6989586621679165729"><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679165729"><span class="hs-identifier hs-var">ksig1</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe (m Type) -&gt; m (Maybe Type)
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe (m Type)
</span><a href="#local-6989586621679165735"><span class="hs-identifier hs-var">ksig</span></a></span><span>
</span><span id="line-538"></span><span>    </span><span id="local-6989586621679165728"><span class="annot"><span class="annottext">Con
</span><a href="#local-6989586621679165728"><span class="hs-identifier hs-var">con1</span></a></span></span><span>    </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Con
</span><a href="#local-6989586621679165734"><span class="hs-identifier hs-var">con</span></a></span><span>
</span><span id="line-539"></span><span>    </span><span id="local-6989586621679165727"><span class="annot"><span class="annottext">[DerivClause]
</span><a href="#local-6989586621679165727"><span class="hs-identifier hs-var">derivs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m DerivClause] -&gt; m [DerivClause]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m DerivClause]
</span><a href="#local-6989586621679165733"><span class="hs-identifier hs-var">derivs</span></a></span><span>
</span><span id="line-540"></span><span>    </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Cxt
-&gt; Maybe [TyVarBndr ()]
-&gt; Type
-&gt; Maybe Type
-&gt; Con
-&gt; [DerivClause]
-&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#NewtypeInstD"><span class="hs-identifier hs-var">NewtypeInstD</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165732"><span class="hs-identifier hs-var">ctxt1</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe [TyVarBndr ()]
</span><a href="#local-6989586621679165731"><span class="hs-identifier hs-var">mb_bndrs1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165730"><span class="hs-identifier hs-var">ty1</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679165729"><span class="hs-identifier hs-var">ksig1</span></a></span><span> </span><span class="annot"><span class="annottext">Con
</span><a href="#local-6989586621679165728"><span class="hs-identifier hs-var">con1</span></a></span><span> </span><span class="annot"><span class="annottext">[DerivClause]
</span><a href="#local-6989586621679165727"><span class="hs-identifier hs-var">derivs1</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-541"></span><span>
</span><span id="line-542"></span><span id="local-6989586621679167063"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tySynInstD"><span class="hs-identifier hs-type">tySynInstD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167063"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167063"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TySynEqn"><span class="hs-identifier hs-type">TySynEqn</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167063"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-543"></span><span id="tySynInstD"><span class="annot"><span class="annottext">tySynInstD :: forall (m :: * -&gt; *). Quote m =&gt; m TySynEqn -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#tySynInstD"><span class="hs-identifier hs-var hs-var">tySynInstD</span></a></span></span><span> </span><span id="local-6989586621679165720"><span class="annot"><span class="annottext">m TySynEqn
</span><a href="#local-6989586621679165720"><span class="hs-identifier hs-var">eqn</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-544"></span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-545"></span><span>    </span><span id="local-6989586621679165719"><span class="annot"><span class="annottext">TySynEqn
</span><a href="#local-6989586621679165719"><span class="hs-identifier hs-var">eqn1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m TySynEqn
</span><a href="#local-6989586621679165720"><span class="hs-identifier hs-var">eqn</span></a></span><span>
</span><span id="line-546"></span><span>    </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TySynEqn -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#TySynInstD"><span class="hs-identifier hs-var">TySynInstD</span></a></span><span> </span><span class="annot"><span class="annottext">TySynEqn
</span><a href="#local-6989586621679165719"><span class="hs-identifier hs-var">eqn1</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-547"></span><span>
</span><span id="line-548"></span><span id="local-6989586621679167061"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#dataFamilyD"><span class="hs-identifier hs-type">dataFamilyD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167061"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167061"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679167061"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167061"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-549"></span><span id="dataFamilyD"><span class="annot"><span class="annottext">dataFamilyD :: forall (m :: * -&gt; *).
Quote m =&gt;
Name -&gt; [m (TyVarBndr ())] -&gt; Maybe (m Type) -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#dataFamilyD"><span class="hs-identifier hs-var hs-var">dataFamilyD</span></a></span></span><span> </span><span id="local-6989586621679165707"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165707"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621679165706"><span class="annot"><span class="annottext">[m (TyVarBndr ())]
</span><a href="#local-6989586621679165706"><span class="hs-identifier hs-var">tvs</span></a></span></span><span> </span><span id="local-6989586621679165705"><span class="annot"><span class="annottext">Maybe (m Type)
</span><a href="#local-6989586621679165705"><span class="hs-identifier hs-var">kind</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-550"></span><span>  </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679165704"><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679165704"><span class="hs-identifier hs-var">tvs'</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())] -&gt; m [TyVarBndr ()]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())]
</span><a href="#local-6989586621679165706"><span class="hs-identifier hs-var">tvs</span></a></span><span>
</span><span id="line-551"></span><span>     </span><span id="local-6989586621679165703"><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679165703"><span class="hs-identifier hs-var">kind'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe (m Type) -&gt; m (Maybe Type)
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe (m Type)
</span><a href="#local-6989586621679165705"><span class="hs-identifier hs-var">kind</span></a></span><span>
</span><span id="line-552"></span><span>     </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Name -&gt; [TyVarBndr ()] -&gt; Maybe Type -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#DataFamilyD"><span class="hs-identifier hs-var">DataFamilyD</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165707"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679165704"><span class="hs-identifier hs-var">tvs'</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679165703"><span class="hs-identifier hs-var">kind'</span></a></span><span>
</span><span id="line-553"></span><span>
</span><span id="line-554"></span><span id="local-6989586621679167059"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#openTypeFamilyD"><span class="hs-identifier hs-type">openTypeFamilyD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167059"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167059"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167059"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FamilyResultSig"><span class="hs-identifier hs-type">FamilyResultSig</span></a></span><span>
</span><span id="line-555"></span><span>                </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#InjectivityAnn"><span class="hs-identifier hs-type">InjectivityAnn</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167059"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-556"></span><span id="openTypeFamilyD"><span class="annot"><span class="annottext">openTypeFamilyD :: forall (m :: * -&gt; *).
Quote m =&gt;
Name
-&gt; [m (TyVarBndr ())]
-&gt; m FamilyResultSig
-&gt; Maybe InjectivityAnn
-&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#openTypeFamilyD"><span class="hs-identifier hs-var hs-var">openTypeFamilyD</span></a></span></span><span> </span><span id="local-6989586621679165693"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165693"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621679165692"><span class="annot"><span class="annottext">[m (TyVarBndr ())]
</span><a href="#local-6989586621679165692"><span class="hs-identifier hs-var">tvs</span></a></span></span><span> </span><span id="local-6989586621679165691"><span class="annot"><span class="annottext">m FamilyResultSig
</span><a href="#local-6989586621679165691"><span class="hs-identifier hs-var">res</span></a></span></span><span> </span><span id="local-6989586621679165690"><span class="annot"><span class="annottext">Maybe InjectivityAnn
</span><a href="#local-6989586621679165690"><span class="hs-identifier hs-var">inj</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-557"></span><span>  </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679165689"><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679165689"><span class="hs-identifier hs-var">tvs'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())] -&gt; m [TyVarBndr ()]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())]
</span><a href="#local-6989586621679165692"><span class="hs-identifier hs-var">tvs</span></a></span><span>
</span><span id="line-558"></span><span>     </span><span id="local-6989586621679165688"><span class="annot"><span class="annottext">FamilyResultSig
</span><a href="#local-6989586621679165688"><span class="hs-identifier hs-var">res'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m FamilyResultSig
</span><a href="#local-6989586621679165691"><span class="hs-identifier hs-var">res</span></a></span><span>
</span><span id="line-559"></span><span>     </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">TypeFamilyHead -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#OpenTypeFamilyD"><span class="hs-identifier hs-var">OpenTypeFamilyD</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name
-&gt; [TyVarBndr ()]
-&gt; FamilyResultSig
-&gt; Maybe InjectivityAnn
-&gt; TypeFamilyHead
</span><a href="Language.Haskell.TH.Syntax.html#TypeFamilyHead"><span class="hs-identifier hs-var">TypeFamilyHead</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165693"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679165689"><span class="hs-identifier hs-var">tvs'</span></a></span><span> </span><span class="annot"><span class="annottext">FamilyResultSig
</span><a href="#local-6989586621679165688"><span class="hs-identifier hs-var">res'</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe InjectivityAnn
</span><a href="#local-6989586621679165690"><span class="hs-identifier hs-var">inj</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-560"></span><span>
</span><span id="line-561"></span><span id="local-6989586621679167054"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#closedTypeFamilyD"><span class="hs-identifier hs-type">closedTypeFamilyD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167054"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167054"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167054"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FamilyResultSig"><span class="hs-identifier hs-type">FamilyResultSig</span></a></span><span>
</span><span id="line-562"></span><span>                  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#InjectivityAnn"><span class="hs-identifier hs-type">InjectivityAnn</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167054"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TySynEqn"><span class="hs-identifier hs-type">TySynEqn</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167054"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-563"></span><span id="closedTypeFamilyD"><span class="annot"><span class="annottext">closedTypeFamilyD :: forall (m :: * -&gt; *).
Quote m =&gt;
Name
-&gt; [m (TyVarBndr ())]
-&gt; m FamilyResultSig
-&gt; Maybe InjectivityAnn
-&gt; [m TySynEqn]
-&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#closedTypeFamilyD"><span class="hs-identifier hs-var hs-var">closedTypeFamilyD</span></a></span></span><span> </span><span id="local-6989586621679165674"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165674"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621679165673"><span class="annot"><span class="annottext">[m (TyVarBndr ())]
</span><a href="#local-6989586621679165673"><span class="hs-identifier hs-var">tvs</span></a></span></span><span> </span><span id="local-6989586621679165672"><span class="annot"><span class="annottext">m FamilyResultSig
</span><a href="#local-6989586621679165672"><span class="hs-identifier hs-var">result</span></a></span></span><span> </span><span id="local-6989586621679165671"><span class="annot"><span class="annottext">Maybe InjectivityAnn
</span><a href="#local-6989586621679165671"><span class="hs-identifier hs-var">injectivity</span></a></span></span><span> </span><span id="local-6989586621679165670"><span class="annot"><span class="annottext">[m TySynEqn]
</span><a href="#local-6989586621679165670"><span class="hs-identifier hs-var">eqns</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-564"></span><span>  </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679165669"><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679165669"><span class="hs-identifier hs-var">tvs1</span></a></span></span><span>    </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())] -&gt; m [TyVarBndr ()]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())]
</span><a href="#local-6989586621679165673"><span class="hs-identifier hs-var">tvs</span></a></span><span>
</span><span id="line-565"></span><span>     </span><span id="local-6989586621679165668"><span class="annot"><span class="annottext">FamilyResultSig
</span><a href="#local-6989586621679165668"><span class="hs-identifier hs-var">result1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m FamilyResultSig
</span><a href="#local-6989586621679165672"><span class="hs-identifier hs-var">result</span></a></span><span>
</span><span id="line-566"></span><span>     </span><span id="local-6989586621679165667"><span class="annot"><span class="annottext">[TySynEqn]
</span><a href="#local-6989586621679165667"><span class="hs-identifier hs-var">eqns1</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m TySynEqn] -&gt; m [TySynEqn]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m TySynEqn]
</span><a href="#local-6989586621679165670"><span class="hs-identifier hs-var">eqns</span></a></span><span>
</span><span id="line-567"></span><span>     </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TypeFamilyHead -&gt; [TySynEqn] -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#ClosedTypeFamilyD"><span class="hs-identifier hs-var">ClosedTypeFamilyD</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name
-&gt; [TyVarBndr ()]
-&gt; FamilyResultSig
-&gt; Maybe InjectivityAnn
-&gt; TypeFamilyHead
</span><a href="Language.Haskell.TH.Syntax.html#TypeFamilyHead"><span class="hs-identifier hs-var">TypeFamilyHead</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165674"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679165669"><span class="hs-identifier hs-var">tvs1</span></a></span><span> </span><span class="annot"><span class="annottext">FamilyResultSig
</span><a href="#local-6989586621679165668"><span class="hs-identifier hs-var">result1</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe InjectivityAnn
</span><a href="#local-6989586621679165671"><span class="hs-identifier hs-var">injectivity</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[TySynEqn]
</span><a href="#local-6989586621679165667"><span class="hs-identifier hs-var">eqns1</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-568"></span><span>
</span><span id="line-569"></span><span id="local-6989586621679167052"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#roleAnnotD"><span class="hs-identifier hs-type">roleAnnotD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167052"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#Role"><span class="hs-identifier hs-type">Role</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167052"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-570"></span><span id="roleAnnotD"><span class="annot"><span class="annottext">roleAnnotD :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; [Role] -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#roleAnnotD"><span class="hs-identifier hs-var hs-var">roleAnnotD</span></a></span></span><span> </span><span id="local-6989586621679165661"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165661"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span id="local-6989586621679165660"><span class="annot"><span class="annottext">[Role]
</span><a href="#local-6989586621679165660"><span class="hs-identifier hs-var">roles</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Name -&gt; [Role] -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#RoleAnnotD"><span class="hs-identifier hs-var">RoleAnnotD</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165661"><span class="hs-identifier hs-var">name</span></a></span><span> </span><span class="annot"><span class="annottext">[Role]
</span><a href="#local-6989586621679165660"><span class="hs-identifier hs-var">roles</span></a></span><span>
</span><span id="line-571"></span><span>
</span><span id="line-572"></span><span id="local-6989586621679167050"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#standaloneDerivD"><span class="hs-identifier hs-type">standaloneDerivD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167050"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167050"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167050"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167050"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-573"></span><span id="standaloneDerivD"><span class="annot"><span class="annottext">standaloneDerivD :: forall (m :: * -&gt; *). Quote m =&gt; m Cxt -&gt; m Type -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#standaloneDerivD"><span class="hs-identifier hs-var hs-var">standaloneDerivD</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (m DerivStrategy) -&gt; m Cxt -&gt; m Type -&gt; m Dec
forall (m :: * -&gt; *).
Quote m =&gt;
Maybe (m DerivStrategy) -&gt; m Cxt -&gt; m Type -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#standaloneDerivWithStrategyD"><span class="hs-identifier hs-var">standaloneDerivWithStrategyD</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe (m DerivStrategy)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-574"></span><span>
</span><span id="line-575"></span><span id="local-6989586621679167048"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#standaloneDerivWithStrategyD"><span class="hs-identifier hs-type">standaloneDerivWithStrategyD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167048"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679167048"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivStrategy"><span class="hs-identifier hs-type">DerivStrategy</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167048"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167048"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167048"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-576"></span><span id="standaloneDerivWithStrategyD"><span class="annot"><span class="annottext">standaloneDerivWithStrategyD :: forall (m :: * -&gt; *).
Quote m =&gt;
Maybe (m DerivStrategy) -&gt; m Cxt -&gt; m Type -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#standaloneDerivWithStrategyD"><span class="hs-identifier hs-var hs-var">standaloneDerivWithStrategyD</span></a></span></span><span> </span><span id="local-6989586621679165646"><span class="annot"><span class="annottext">Maybe (m DerivStrategy)
</span><a href="#local-6989586621679165646"><span class="hs-identifier hs-var">mdsq</span></a></span></span><span> </span><span id="local-6989586621679165645"><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679165645"><span class="hs-identifier hs-var">ctxtq</span></a></span></span><span> </span><span id="local-6989586621679165644"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165644"><span class="hs-identifier hs-var">tyq</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-577"></span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-578"></span><span>    </span><span id="local-6989586621679165643"><span class="annot"><span class="annottext">Maybe DerivStrategy
</span><a href="#local-6989586621679165643"><span class="hs-identifier hs-var">mds</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe (m DerivStrategy) -&gt; m (Maybe DerivStrategy)
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe (m DerivStrategy)
</span><a href="#local-6989586621679165646"><span class="hs-identifier hs-var">mdsq</span></a></span><span>
</span><span id="line-579"></span><span>    </span><span id="local-6989586621679165642"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165642"><span class="hs-identifier hs-var">ctxt</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679165645"><span class="hs-identifier hs-var">ctxtq</span></a></span><span>
</span><span id="line-580"></span><span>    </span><span id="local-6989586621679165641"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165641"><span class="hs-identifier hs-var">ty</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165644"><span class="hs-identifier hs-var">tyq</span></a></span><span>
</span><span id="line-581"></span><span>    </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe DerivStrategy -&gt; Cxt -&gt; Type -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#StandaloneDerivD"><span class="hs-identifier hs-var">StandaloneDerivD</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe DerivStrategy
</span><a href="#local-6989586621679165643"><span class="hs-identifier hs-var">mds</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165642"><span class="hs-identifier hs-var">ctxt</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165641"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-582"></span><span>
</span><span id="line-583"></span><span id="local-6989586621679165639"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#defaultSigD"><span class="hs-identifier hs-type">defaultSigD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165639"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165639"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165639"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-584"></span><span id="defaultSigD"><span class="annot"><span class="annottext">defaultSigD :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Type -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#defaultSigD"><span class="hs-identifier hs-var hs-var">defaultSigD</span></a></span></span><span> </span><span id="local-6989586621679165633"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165633"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679165632"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165632"><span class="hs-identifier hs-var">tyq</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-585"></span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-586"></span><span>    </span><span id="local-6989586621679165631"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165631"><span class="hs-identifier hs-var">ty</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165632"><span class="hs-identifier hs-var">tyq</span></a></span><span>
</span><span id="line-587"></span><span>    </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Name -&gt; Type -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#DefaultSigD"><span class="hs-identifier hs-var">DefaultSigD</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165633"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165631"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-588"></span><span>
</span><span id="line-589"></span><span class="hs-comment">-- | Pattern synonym declaration</span><span>
</span><span id="line-590"></span><span id="local-6989586621679167045"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#patSynD"><span class="hs-identifier hs-type">patSynD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167045"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167045"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#PatSynArgs"><span class="hs-identifier hs-type">PatSynArgs</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167045"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#PatSynDir"><span class="hs-identifier hs-type">PatSynDir</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167045"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pat"><span class="hs-identifier hs-type">Pat</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167045"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-591"></span><span id="patSynD"><span class="annot"><span class="annottext">patSynD :: forall (m :: * -&gt; *).
Quote m =&gt;
Name -&gt; m PatSynArgs -&gt; m PatSynDir -&gt; m Pat -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#patSynD"><span class="hs-identifier hs-var hs-var">patSynD</span></a></span></span><span> </span><span id="local-6989586621679165622"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165622"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span id="local-6989586621679165621"><span class="annot"><span class="annottext">m PatSynArgs
</span><a href="#local-6989586621679165621"><span class="hs-identifier hs-var">args</span></a></span></span><span> </span><span id="local-6989586621679165620"><span class="annot"><span class="annottext">m PatSynDir
</span><a href="#local-6989586621679165620"><span class="hs-identifier hs-var">dir</span></a></span></span><span> </span><span id="local-6989586621679165619"><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679165619"><span class="hs-identifier hs-var">pat</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-592"></span><span>  </span><span id="local-6989586621679165618"><span class="annot"><span class="annottext">PatSynArgs
</span><a href="#local-6989586621679165618"><span class="hs-identifier hs-var">args'</span></a></span></span><span>    </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m PatSynArgs
</span><a href="#local-6989586621679165621"><span class="hs-identifier hs-var">args</span></a></span><span>
</span><span id="line-593"></span><span>  </span><span id="local-6989586621679165617"><span class="annot"><span class="annottext">PatSynDir
</span><a href="#local-6989586621679165617"><span class="hs-identifier hs-var">dir'</span></a></span></span><span>     </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m PatSynDir
</span><a href="#local-6989586621679165620"><span class="hs-identifier hs-var">dir</span></a></span><span>
</span><span id="line-594"></span><span>  </span><span id="local-6989586621679165616"><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679165616"><span class="hs-identifier hs-var">pat'</span></a></span></span><span>     </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Pat
</span><a href="#local-6989586621679165619"><span class="hs-identifier hs-var">pat</span></a></span><span>
</span><span id="line-595"></span><span>  </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; PatSynArgs -&gt; PatSynDir -&gt; Pat -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#PatSynD"><span class="hs-identifier hs-var">PatSynD</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165622"><span class="hs-identifier hs-var">name</span></a></span><span> </span><span class="annot"><span class="annottext">PatSynArgs
</span><a href="#local-6989586621679165618"><span class="hs-identifier hs-var">args'</span></a></span><span> </span><span class="annot"><span class="annottext">PatSynDir
</span><a href="#local-6989586621679165617"><span class="hs-identifier hs-var">dir'</span></a></span><span> </span><span class="annot"><span class="annottext">Pat
</span><a href="#local-6989586621679165616"><span class="hs-identifier hs-var">pat'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-596"></span><span>
</span><span id="line-597"></span><span class="hs-comment">-- | Pattern synonym type signature</span><span>
</span><span id="line-598"></span><span id="local-6989586621679165614"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#patSynSigD"><span class="hs-identifier hs-type">patSynSigD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165614"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165614"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165614"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-599"></span><span id="patSynSigD"><span class="annot"><span class="annottext">patSynSigD :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Type -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#patSynSigD"><span class="hs-identifier hs-var hs-var">patSynSigD</span></a></span></span><span> </span><span id="local-6989586621679165608"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165608"><span class="hs-identifier hs-var">nm</span></a></span></span><span> </span><span id="local-6989586621679165607"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165607"><span class="hs-identifier hs-var">ty</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-600"></span><span>  </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679165606"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165606"><span class="hs-identifier hs-var">ty'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165607"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-601"></span><span>     </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Name -&gt; Type -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#PatSynSigD"><span class="hs-identifier hs-var">PatSynSigD</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165608"><span class="hs-identifier hs-var">nm</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165606"><span class="hs-identifier hs-var">ty'</span></a></span><span>
</span><span id="line-602"></span><span>
</span><span id="line-603"></span><span class="hs-comment">-- | Implicit parameter binding declaration. Can only be used in let</span><span>
</span><span id="line-604"></span><span class="hs-comment">-- and where clauses which consist entirely of implicit bindings.</span><span>
</span><span id="line-605"></span><span id="local-6989586621679167040"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#implicitParamBindD"><span class="hs-identifier hs-type">implicitParamBindD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167040"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167040"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167040"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-606"></span><span id="implicitParamBindD"><span class="annot"><span class="annottext">implicitParamBindD :: forall (m :: * -&gt; *). Quote m =&gt; String -&gt; m Exp -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.Internal.html#implicitParamBindD"><span class="hs-identifier hs-var hs-var">implicitParamBindD</span></a></span></span><span> </span><span id="local-6989586621679165599"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679165599"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679165598"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679165598"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-607"></span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-608"></span><span>    </span><span id="local-6989586621679165597"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679165597"><span class="hs-identifier hs-var">e'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679165598"><span class="hs-identifier hs-var">e</span></a></span><span>
</span><span id="line-609"></span><span>    </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; Exp -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#ImplicitParamBindD"><span class="hs-identifier hs-var">ImplicitParamBindD</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679165599"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679165597"><span class="hs-identifier hs-var">e'</span></a></span><span>
</span><span id="line-610"></span><span>
</span><span id="line-611"></span><span id="local-6989586621679167038"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tySynEqn"><span class="hs-identifier hs-type">tySynEqn</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167038"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167038"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">]</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167038"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167038"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167038"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TySynEqn"><span class="hs-identifier hs-type">TySynEqn</span></a></span></span><span>
</span><span id="line-612"></span><span id="tySynEqn"><span class="annot"><span class="annottext">tySynEqn :: forall (m :: * -&gt; *).
Quote m =&gt;
Maybe [m (TyVarBndr ())] -&gt; m Type -&gt; m Type -&gt; m TySynEqn
</span><a href="Language.Haskell.TH.Lib.Internal.html#tySynEqn"><span class="hs-identifier hs-var hs-var">tySynEqn</span></a></span></span><span> </span><span id="local-6989586621679165584"><span class="annot"><span class="annottext">Maybe [m (TyVarBndr ())]
</span><a href="#local-6989586621679165584"><span class="hs-identifier hs-var">mb_bndrs</span></a></span></span><span> </span><span id="local-6989586621679165583"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165583"><span class="hs-identifier hs-var">lhs</span></a></span></span><span> </span><span id="local-6989586621679165582"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165582"><span class="hs-identifier hs-var">rhs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-613"></span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-614"></span><span>    </span><span id="local-6989586621679165581"><span class="annot"><span class="annottext">Maybe [TyVarBndr ()]
</span><a href="#local-6989586621679165581"><span class="hs-identifier hs-var">mb_bndrs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">([m (TyVarBndr ())] -&gt; m [TyVarBndr ()])
-&gt; Maybe [m (TyVarBndr ())] -&gt; m (Maybe [TyVarBndr ()])
forall (t :: * -&gt; *) (f :: * -&gt; *) a b.
(Traversable t, Applicative f) =&gt;
(a -&gt; f b) -&gt; t a -&gt; f (t b)
</span><a href="../../base/src/Data.Traversable.html#traverse"><span class="hs-identifier hs-var">traverse</span></a></span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())] -&gt; m [TyVarBndr ()]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe [m (TyVarBndr ())]
</span><a href="#local-6989586621679165584"><span class="hs-identifier hs-var">mb_bndrs</span></a></span><span>
</span><span id="line-615"></span><span>    </span><span id="local-6989586621679165580"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165580"><span class="hs-identifier hs-var">lhs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165583"><span class="hs-identifier hs-var">lhs</span></a></span><span>
</span><span id="line-616"></span><span>    </span><span id="local-6989586621679165579"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165579"><span class="hs-identifier hs-var">rhs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165582"><span class="hs-identifier hs-var">rhs</span></a></span><span>
</span><span id="line-617"></span><span>    </span><span class="annot"><span class="annottext">TySynEqn -&gt; m TySynEqn
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe [TyVarBndr ()] -&gt; Type -&gt; Type -&gt; TySynEqn
</span><a href="Language.Haskell.TH.Syntax.html#TySynEqn"><span class="hs-identifier hs-var">TySynEqn</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe [TyVarBndr ()]
</span><a href="#local-6989586621679165581"><span class="hs-identifier hs-var">mb_bndrs1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165580"><span class="hs-identifier hs-var">lhs1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165579"><span class="hs-identifier hs-var">rhs1</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-618"></span><span>
</span><span id="line-619"></span><span id="local-6989586621679167036"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#cxt"><span class="hs-identifier hs-type">cxt</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167036"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167036"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pred"><span class="hs-identifier hs-type">Pred</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167036"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span></span><span>
</span><span id="line-620"></span><span id="cxt"><span class="annot"><span class="annottext">cxt :: forall (m :: * -&gt; *). Quote m =&gt; [m Type] -&gt; m Cxt
</span><a href="Language.Haskell.TH.Lib.Internal.html#cxt"><span class="hs-identifier hs-var hs-var">cxt</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[m Type] -&gt; m Cxt
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span>
</span><span id="line-621"></span><span>
</span><span id="line-622"></span><span id="local-6989586621679167034"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#derivClause"><span class="hs-identifier hs-type">derivClause</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167034"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679167034"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivStrategy"><span class="hs-identifier hs-type">DerivStrategy</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167034"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pred"><span class="hs-identifier hs-type">Pred</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167034"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivClause"><span class="hs-identifier hs-type">DerivClause</span></a></span></span><span>
</span><span id="line-623"></span><span id="derivClause"><span class="annot"><span class="annottext">derivClause :: forall (m :: * -&gt; *).
Quote m =&gt;
Maybe (m DerivStrategy) -&gt; [m Type] -&gt; m DerivClause
</span><a href="Language.Haskell.TH.Lib.Internal.html#derivClause"><span class="hs-identifier hs-var hs-var">derivClause</span></a></span></span><span> </span><span id="local-6989586621679165563"><span class="annot"><span class="annottext">Maybe (m DerivStrategy)
</span><a href="#local-6989586621679165563"><span class="hs-identifier hs-var">mds</span></a></span></span><span> </span><span id="local-6989586621679165562"><span class="annot"><span class="annottext">[m Type]
</span><a href="#local-6989586621679165562"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679165561"><span class="annot"><span class="annottext">Maybe DerivStrategy
</span><a href="#local-6989586621679165561"><span class="hs-identifier hs-var">mds'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Maybe (m DerivStrategy) -&gt; m (Maybe DerivStrategy)
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe (m DerivStrategy)
</span><a href="#local-6989586621679165563"><span class="hs-identifier hs-var">mds</span></a></span><span>
</span><span id="line-624"></span><span>                       </span><span id="local-6989586621679165560"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165560"><span class="hs-identifier hs-var">p'</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Type] -&gt; m Cxt
forall (m :: * -&gt; *). Quote m =&gt; [m Type] -&gt; m Cxt
</span><a href="Language.Haskell.TH.Lib.Internal.html#cxt"><span class="hs-identifier hs-var">cxt</span></a></span><span> </span><span class="annot"><span class="annottext">[m Type]
</span><a href="#local-6989586621679165562"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-625"></span><span>                       </span><span class="annot"><span class="annottext">DerivClause -&gt; m DerivClause
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(DerivClause -&gt; m DerivClause) -&gt; DerivClause -&gt; m DerivClause
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe DerivStrategy -&gt; Cxt -&gt; DerivClause
</span><a href="Language.Haskell.TH.Syntax.html#DerivClause"><span class="hs-identifier hs-var">DerivClause</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe DerivStrategy
</span><a href="#local-6989586621679165561"><span class="hs-identifier hs-var">mds'</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165560"><span class="hs-identifier hs-var">p'</span></a></span><span>
</span><span id="line-626"></span><span>
</span><span id="line-627"></span><span id="local-6989586621679167032"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#stockStrategy"><span class="hs-identifier hs-type">stockStrategy</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167032"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167032"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivStrategy"><span class="hs-identifier hs-type">DerivStrategy</span></a></span></span><span>
</span><span id="line-628"></span><span id="stockStrategy"><span class="annot"><span class="annottext">stockStrategy :: forall (m :: * -&gt; *). Quote m =&gt; m DerivStrategy
</span><a href="Language.Haskell.TH.Lib.Internal.html#stockStrategy"><span class="hs-identifier hs-var hs-var">stockStrategy</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">DerivStrategy -&gt; m DerivStrategy
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">DerivStrategy
</span><a href="Language.Haskell.TH.Syntax.html#StockStrategy"><span class="hs-identifier hs-var">StockStrategy</span></a></span><span>
</span><span id="line-629"></span><span>
</span><span id="line-630"></span><span id="local-6989586621679165553"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#anyclassStrategy"><span class="hs-identifier hs-type">anyclassStrategy</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165553"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165553"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivStrategy"><span class="hs-identifier hs-type">DerivStrategy</span></a></span></span><span>
</span><span id="line-631"></span><span id="anyclassStrategy"><span class="annot"><span class="annottext">anyclassStrategy :: forall (m :: * -&gt; *). Quote m =&gt; m DerivStrategy
</span><a href="Language.Haskell.TH.Lib.Internal.html#anyclassStrategy"><span class="hs-identifier hs-var hs-var">anyclassStrategy</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">DerivStrategy -&gt; m DerivStrategy
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">DerivStrategy
</span><a href="Language.Haskell.TH.Syntax.html#AnyclassStrategy"><span class="hs-identifier hs-var">AnyclassStrategy</span></a></span><span>
</span><span id="line-632"></span><span>
</span><span id="line-633"></span><span id="local-6989586621679165547"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#newtypeStrategy"><span class="hs-identifier hs-type">newtypeStrategy</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165547"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165547"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivStrategy"><span class="hs-identifier hs-type">DerivStrategy</span></a></span></span><span>
</span><span id="line-634"></span><span id="newtypeStrategy"><span class="annot"><span class="annottext">newtypeStrategy :: forall (m :: * -&gt; *). Quote m =&gt; m DerivStrategy
</span><a href="Language.Haskell.TH.Lib.Internal.html#newtypeStrategy"><span class="hs-identifier hs-var hs-var">newtypeStrategy</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">DerivStrategy -&gt; m DerivStrategy
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">DerivStrategy
</span><a href="Language.Haskell.TH.Syntax.html#NewtypeStrategy"><span class="hs-identifier hs-var">NewtypeStrategy</span></a></span><span>
</span><span id="line-635"></span><span>
</span><span id="line-636"></span><span id="local-6989586621679167028"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#viaStrategy"><span class="hs-identifier hs-type">viaStrategy</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167028"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167028"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167028"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivStrategy"><span class="hs-identifier hs-type">DerivStrategy</span></a></span></span><span>
</span><span id="line-637"></span><span id="viaStrategy"><span class="annot"><span class="annottext">viaStrategy :: forall (m :: * -&gt; *). Quote m =&gt; m Type -&gt; m DerivStrategy
</span><a href="Language.Haskell.TH.Lib.Internal.html#viaStrategy"><span class="hs-identifier hs-var hs-var">viaStrategy</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Type -&gt; DerivStrategy) -&gt; m Type -&gt; m DerivStrategy
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; DerivStrategy
</span><a href="Language.Haskell.TH.Syntax.html#ViaStrategy"><span class="hs-identifier hs-var">ViaStrategy</span></a></span><span>
</span><span id="line-638"></span><span>
</span><span id="line-639"></span><span id="local-6989586621679167026"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#normalC"><span class="hs-identifier hs-type">normalC</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167026"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167026"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#BangType"><span class="hs-identifier hs-type">BangType</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167026"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span></span><span>
</span><span id="line-640"></span><span id="normalC"><span class="annot"><span class="annottext">normalC :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; [m BangType] -&gt; m Con
</span><a href="Language.Haskell.TH.Lib.Internal.html#normalC"><span class="hs-identifier hs-var hs-var">normalC</span></a></span></span><span> </span><span id="local-6989586621679165529"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165529"><span class="hs-identifier hs-var">con</span></a></span></span><span> </span><span id="local-6989586621679165528"><span class="annot"><span class="annottext">[m BangType]
</span><a href="#local-6989586621679165528"><span class="hs-identifier hs-var">strtys</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">([BangType] -&gt; Con) -&gt; m [BangType] -&gt; m Con
forall (f :: * -&gt; *) a b. Applicative f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#liftA"><span class="hs-identifier hs-var">liftA</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; [BangType] -&gt; Con
</span><a href="Language.Haskell.TH.Syntax.html#NormalC"><span class="hs-identifier hs-var">NormalC</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165529"><span class="hs-identifier hs-var">con</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(m [BangType] -&gt; m Con) -&gt; m [BangType] -&gt; m Con
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">[m BangType] -&gt; m [BangType]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m BangType]
</span><a href="#local-6989586621679165528"><span class="hs-identifier hs-var">strtys</span></a></span><span>
</span><span id="line-641"></span><span>
</span><span id="line-642"></span><span id="local-6989586621679167024"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#recC"><span class="hs-identifier hs-type">recC</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167024"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167024"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#VarBangType"><span class="hs-identifier hs-type">VarBangType</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167024"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span></span><span>
</span><span id="line-643"></span><span id="recC"><span class="annot"><span class="annottext">recC :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; [m VarBangType] -&gt; m Con
</span><a href="Language.Haskell.TH.Lib.Internal.html#recC"><span class="hs-identifier hs-var hs-var">recC</span></a></span></span><span> </span><span id="local-6989586621679165520"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165520"><span class="hs-identifier hs-var">con</span></a></span></span><span> </span><span id="local-6989586621679165519"><span class="annot"><span class="annottext">[m VarBangType]
</span><a href="#local-6989586621679165519"><span class="hs-identifier hs-var">varstrtys</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">([VarBangType] -&gt; Con) -&gt; m [VarBangType] -&gt; m Con
forall (f :: * -&gt; *) a b. Applicative f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#liftA"><span class="hs-identifier hs-var">liftA</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; [VarBangType] -&gt; Con
</span><a href="Language.Haskell.TH.Syntax.html#RecC"><span class="hs-identifier hs-var">RecC</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165520"><span class="hs-identifier hs-var">con</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(m [VarBangType] -&gt; m Con) -&gt; m [VarBangType] -&gt; m Con
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">[m VarBangType] -&gt; m [VarBangType]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m VarBangType]
</span><a href="#local-6989586621679165519"><span class="hs-identifier hs-var">varstrtys</span></a></span><span>
</span><span id="line-644"></span><span>
</span><span id="line-645"></span><span id="local-6989586621679167022"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixC"><span class="hs-identifier hs-type">infixC</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167022"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167022"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Bang"><span class="hs-identifier hs-type">Bang</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167022"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Bang"><span class="hs-identifier hs-type">Bang</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167022"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span></span><span>
</span><span id="line-646"></span><span id="infixC"><span class="annot"><span class="annottext">infixC :: forall (m :: * -&gt; *).
Quote m =&gt;
m BangType -&gt; Name -&gt; m BangType -&gt; m Con
</span><a href="Language.Haskell.TH.Lib.Internal.html#infixC"><span class="hs-identifier hs-var hs-var">infixC</span></a></span></span><span> </span><span id="local-6989586621679165511"><span class="annot"><span class="annottext">m BangType
</span><a href="#local-6989586621679165511"><span class="hs-identifier hs-var">st1</span></a></span></span><span> </span><span id="local-6989586621679165510"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165510"><span class="hs-identifier hs-var">con</span></a></span></span><span> </span><span id="local-6989586621679165509"><span class="annot"><span class="annottext">m BangType
</span><a href="#local-6989586621679165509"><span class="hs-identifier hs-var">st2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679165508"><span class="annot"><span class="annottext">BangType
</span><a href="#local-6989586621679165508"><span class="hs-identifier hs-var">st1'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m BangType
</span><a href="#local-6989586621679165511"><span class="hs-identifier hs-var">st1</span></a></span><span>
</span><span id="line-647"></span><span>                        </span><span id="local-6989586621679165507"><span class="annot"><span class="annottext">BangType
</span><a href="#local-6989586621679165507"><span class="hs-identifier hs-var">st2'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m BangType
</span><a href="#local-6989586621679165509"><span class="hs-identifier hs-var">st2</span></a></span><span>
</span><span id="line-648"></span><span>                        </span><span class="annot"><span class="annottext">Con -&gt; m Con
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Con -&gt; m Con) -&gt; Con -&gt; m Con
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">BangType -&gt; Name -&gt; BangType -&gt; Con
</span><a href="Language.Haskell.TH.Syntax.html#InfixC"><span class="hs-identifier hs-var">InfixC</span></a></span><span> </span><span class="annot"><span class="annottext">BangType
</span><a href="#local-6989586621679165508"><span class="hs-identifier hs-var">st1'</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165510"><span class="hs-identifier hs-var">con</span></a></span><span> </span><span class="annot"><span class="annottext">BangType
</span><a href="#local-6989586621679165507"><span class="hs-identifier hs-var">st2'</span></a></span><span>
</span><span id="line-649"></span><span>
</span><span id="line-650"></span><span id="local-6989586621679167020"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#forallC"><span class="hs-identifier hs-type">forallC</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167020"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167020"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Specificity"><span class="hs-identifier hs-type">Specificity</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167020"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167020"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167020"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span></span><span>
</span><span id="line-651"></span><span id="forallC"><span class="annot"><span class="annottext">forallC :: forall (m :: * -&gt; *).
Quote m =&gt;
[m (TyVarBndr Specificity)] -&gt; m Cxt -&gt; m Con -&gt; m Con
</span><a href="Language.Haskell.TH.Lib.Internal.html#forallC"><span class="hs-identifier hs-var hs-var">forallC</span></a></span></span><span> </span><span id="local-6989586621679165496"><span class="annot"><span class="annottext">[m (TyVarBndr Specificity)]
</span><a href="#local-6989586621679165496"><span class="hs-identifier hs-var">ns</span></a></span></span><span> </span><span id="local-6989586621679165495"><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679165495"><span class="hs-identifier hs-var">ctxt</span></a></span></span><span> </span><span id="local-6989586621679165494"><span class="annot"><span class="annottext">m Con
</span><a href="#local-6989586621679165494"><span class="hs-identifier hs-var">con</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-652"></span><span>  </span><span id="local-6989586621679165493"><span class="annot"><span class="annottext">[TyVarBndr Specificity]
</span><a href="#local-6989586621679165493"><span class="hs-identifier hs-var">ns'</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr Specificity)] -&gt; m [TyVarBndr Specificity]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr Specificity)]
</span><a href="#local-6989586621679165496"><span class="hs-identifier hs-var">ns</span></a></span><span>
</span><span id="line-653"></span><span>  </span><span id="local-6989586621679165492"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165492"><span class="hs-identifier hs-var">ctxt'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679165495"><span class="hs-identifier hs-var">ctxt</span></a></span><span>
</span><span id="line-654"></span><span>  </span><span id="local-6989586621679165491"><span class="annot"><span class="annottext">Con
</span><a href="#local-6989586621679165491"><span class="hs-identifier hs-var">con'</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Con
</span><a href="#local-6989586621679165494"><span class="hs-identifier hs-var">con</span></a></span><span>
</span><span id="line-655"></span><span>  </span><span class="annot"><span class="annottext">Con -&gt; m Con
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Con -&gt; m Con) -&gt; Con -&gt; m Con
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr Specificity] -&gt; Cxt -&gt; Con -&gt; Con
</span><a href="Language.Haskell.TH.Syntax.html#ForallC"><span class="hs-identifier hs-var">ForallC</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr Specificity]
</span><a href="#local-6989586621679165493"><span class="hs-identifier hs-var">ns'</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165492"><span class="hs-identifier hs-var">ctxt'</span></a></span><span> </span><span class="annot"><span class="annottext">Con
</span><a href="#local-6989586621679165491"><span class="hs-identifier hs-var">con'</span></a></span><span>
</span><span id="line-656"></span><span>
</span><span id="line-657"></span><span id="local-6989586621679167017"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#gadtC"><span class="hs-identifier hs-type">gadtC</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167017"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167017"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#StrictType"><span class="hs-identifier hs-type">StrictType</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167017"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167017"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span></span><span>
</span><span id="line-658"></span><span id="gadtC"><span class="annot"><span class="annottext">gadtC :: forall (m :: * -&gt; *).
Quote m =&gt;
[Name] -&gt; [m BangType] -&gt; m Type -&gt; m Con
</span><a href="Language.Haskell.TH.Lib.Internal.html#gadtC"><span class="hs-identifier hs-var hs-var">gadtC</span></a></span></span><span> </span><span id="local-6989586621679165483"><span class="annot"><span class="annottext">[Name]
</span><a href="#local-6989586621679165483"><span class="hs-identifier hs-var">cons</span></a></span></span><span> </span><span id="local-6989586621679165482"><span class="annot"><span class="annottext">[m BangType]
</span><a href="#local-6989586621679165482"><span class="hs-identifier hs-var">strtys</span></a></span></span><span> </span><span id="local-6989586621679165481"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165481"><span class="hs-identifier hs-var">ty</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">([BangType] -&gt; Type -&gt; Con) -&gt; m [BangType] -&gt; m Type -&gt; m Con
forall (f :: * -&gt; *) a b c.
Applicative f =&gt;
(a -&gt; b -&gt; c) -&gt; f a -&gt; f b -&gt; f c
</span><a href="../../base/src/GHC.Base.html#liftA2"><span class="hs-identifier hs-var">liftA2</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Name] -&gt; [BangType] -&gt; Type -&gt; Con
</span><a href="Language.Haskell.TH.Syntax.html#GadtC"><span class="hs-identifier hs-var">GadtC</span></a></span><span> </span><span class="annot"><span class="annottext">[Name]
</span><a href="#local-6989586621679165483"><span class="hs-identifier hs-var">cons</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[m BangType] -&gt; m [BangType]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m BangType]
</span><a href="#local-6989586621679165482"><span class="hs-identifier hs-var">strtys</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165481"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-659"></span><span>
</span><span id="line-660"></span><span id="local-6989586621679167015"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#recGadtC"><span class="hs-identifier hs-type">recGadtC</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167015"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167015"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#VarStrictType"><span class="hs-identifier hs-type">VarStrictType</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167015"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167015"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span></span><span>
</span><span id="line-661"></span><span id="recGadtC"><span class="annot"><span class="annottext">recGadtC :: forall (m :: * -&gt; *).
Quote m =&gt;
[Name] -&gt; [m VarBangType] -&gt; m Type -&gt; m Con
</span><a href="Language.Haskell.TH.Lib.Internal.html#recGadtC"><span class="hs-identifier hs-var hs-var">recGadtC</span></a></span></span><span> </span><span id="local-6989586621679165473"><span class="annot"><span class="annottext">[Name]
</span><a href="#local-6989586621679165473"><span class="hs-identifier hs-var">cons</span></a></span></span><span> </span><span id="local-6989586621679165472"><span class="annot"><span class="annottext">[m VarBangType]
</span><a href="#local-6989586621679165472"><span class="hs-identifier hs-var">varstrtys</span></a></span></span><span> </span><span id="local-6989586621679165471"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165471"><span class="hs-identifier hs-var">ty</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">([VarBangType] -&gt; Type -&gt; Con)
-&gt; m [VarBangType] -&gt; m Type -&gt; m Con
forall (f :: * -&gt; *) a b c.
Applicative f =&gt;
(a -&gt; b -&gt; c) -&gt; f a -&gt; f b -&gt; f c
</span><a href="../../base/src/GHC.Base.html#liftA2"><span class="hs-identifier hs-var">liftA2</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Name] -&gt; [VarBangType] -&gt; Type -&gt; Con
</span><a href="Language.Haskell.TH.Syntax.html#RecGadtC"><span class="hs-identifier hs-var">RecGadtC</span></a></span><span> </span><span class="annot"><span class="annottext">[Name]
</span><a href="#local-6989586621679165473"><span class="hs-identifier hs-var">cons</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[m VarBangType] -&gt; m [VarBangType]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m VarBangType]
</span><a href="#local-6989586621679165472"><span class="hs-identifier hs-var">varstrtys</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165471"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-662"></span><span>
</span><span id="line-663"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-664"></span><span class="hs-comment">-- *   Type</span><span>
</span><span id="line-665"></span><span>
</span><span id="line-666"></span><span id="local-6989586621679167013"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#forallT"><span class="hs-identifier hs-type">forallT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167013"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167013"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Specificity"><span class="hs-identifier hs-type">Specificity</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167013"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167013"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167013"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-667"></span><span id="forallT"><span class="annot"><span class="annottext">forallT :: forall (m :: * -&gt; *).
Quote m =&gt;
[m (TyVarBndr Specificity)] -&gt; m Cxt -&gt; m Type -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#forallT"><span class="hs-identifier hs-var hs-var">forallT</span></a></span></span><span> </span><span id="local-6989586621679165460"><span class="annot"><span class="annottext">[m (TyVarBndr Specificity)]
</span><a href="#local-6989586621679165460"><span class="hs-identifier hs-var">tvars</span></a></span></span><span> </span><span id="local-6989586621679165459"><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679165459"><span class="hs-identifier hs-var">ctxt</span></a></span></span><span> </span><span id="local-6989586621679165458"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165458"><span class="hs-identifier hs-var">ty</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-668"></span><span>    </span><span id="local-6989586621679165457"><span class="annot"><span class="annottext">[TyVarBndr Specificity]
</span><a href="#local-6989586621679165457"><span class="hs-identifier hs-var">tvars1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr Specificity)] -&gt; m [TyVarBndr Specificity]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr Specificity)]
</span><a href="#local-6989586621679165460"><span class="hs-identifier hs-var">tvars</span></a></span><span>
</span><span id="line-669"></span><span>    </span><span id="local-6989586621679165456"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165456"><span class="hs-identifier hs-var">ctxt1</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679165459"><span class="hs-identifier hs-var">ctxt</span></a></span><span>
</span><span id="line-670"></span><span>    </span><span id="local-6989586621679165455"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165455"><span class="hs-identifier hs-var">ty1</span></a></span></span><span>    </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165458"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-671"></span><span>    </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Type -&gt; m Type) -&gt; Type -&gt; m Type
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr Specificity] -&gt; Cxt -&gt; Type -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#ForallT"><span class="hs-identifier hs-var">ForallT</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr Specificity]
</span><a href="#local-6989586621679165457"><span class="hs-identifier hs-var">tvars1</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165456"><span class="hs-identifier hs-var">ctxt1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165455"><span class="hs-identifier hs-var">ty1</span></a></span><span>
</span><span id="line-672"></span><span>
</span><span id="line-673"></span><span id="local-6989586621679167011"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#forallVisT"><span class="hs-identifier hs-type">forallVisT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167011"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167011"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167011"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167011"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-674"></span><span id="forallVisT"><span class="annot"><span class="annottext">forallVisT :: forall (m :: * -&gt; *).
Quote m =&gt;
[m (TyVarBndr ())] -&gt; m Type -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#forallVisT"><span class="hs-identifier hs-var hs-var">forallVisT</span></a></span></span><span> </span><span id="local-6989586621679165445"><span class="annot"><span class="annottext">[m (TyVarBndr ())]
</span><a href="#local-6989586621679165445"><span class="hs-identifier hs-var">tvars</span></a></span></span><span> </span><span id="local-6989586621679165444"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165444"><span class="hs-identifier hs-var">ty</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[TyVarBndr ()] -&gt; Type -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#ForallVisT"><span class="hs-identifier hs-var">ForallVisT</span></a></span><span> </span><span class="annot"><span class="annottext">([TyVarBndr ()] -&gt; Type -&gt; Type)
-&gt; m [TyVarBndr ()] -&gt; m (Type -&gt; Type)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())] -&gt; m [TyVarBndr ()]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m (TyVarBndr ())]
</span><a href="#local-6989586621679165445"><span class="hs-identifier hs-var">tvars</span></a></span><span> </span><span class="annot"><span class="annottext">m (Type -&gt; Type) -&gt; m Type -&gt; m Type
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165444"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-675"></span><span>
</span><span id="line-676"></span><span id="local-6989586621679167007"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#varT"><span class="hs-identifier hs-type">varT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167007"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167007"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-677"></span><span id="varT"><span class="annot"><span class="annottext">varT :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#varT"><span class="hs-identifier hs-var hs-var">varT</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Type -&gt; m Type) -&gt; (Name -&gt; Type) -&gt; Name -&gt; m Type
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Name -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#VarT"><span class="hs-identifier hs-var">VarT</span></a></span><span>
</span><span id="line-678"></span><span>
</span><span id="line-679"></span><span id="local-6989586621679165437"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#conT"><span class="hs-identifier hs-type">conT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165437"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165437"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-680"></span><span id="conT"><span class="annot"><span class="annottext">conT :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#conT"><span class="hs-identifier hs-var hs-var">conT</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Type -&gt; m Type) -&gt; (Name -&gt; Type) -&gt; Name -&gt; m Type
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Name -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#ConT"><span class="hs-identifier hs-var">ConT</span></a></span><span>
</span><span id="line-681"></span><span>
</span><span id="line-682"></span><span id="local-6989586621679167004"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixT"><span class="hs-identifier hs-type">infixT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167004"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167004"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167004"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167004"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-683"></span><span id="infixT"><span class="annot"><span class="annottext">infixT :: forall (m :: * -&gt; *). Quote m =&gt; m Type -&gt; Name -&gt; m Type -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#infixT"><span class="hs-identifier hs-var hs-var">infixT</span></a></span></span><span> </span><span id="local-6989586621679165425"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165425"><span class="hs-identifier hs-var">t1</span></a></span></span><span> </span><span id="local-6989586621679165424"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165424"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679165423"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165423"><span class="hs-identifier hs-var">t2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679165422"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165422"><span class="hs-identifier hs-var">t1'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165425"><span class="hs-identifier hs-var">t1</span></a></span><span>
</span><span id="line-684"></span><span>                    </span><span id="local-6989586621679165421"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165421"><span class="hs-identifier hs-var">t2'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165423"><span class="hs-identifier hs-var">t2</span></a></span><span>
</span><span id="line-685"></span><span>                    </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Type -&gt; Name -&gt; Type -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#InfixT"><span class="hs-identifier hs-var">InfixT</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165422"><span class="hs-identifier hs-var">t1'</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165424"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165421"><span class="hs-identifier hs-var">t2'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-686"></span><span>
</span><span id="line-687"></span><span id="local-6989586621679165419"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#uInfixT"><span class="hs-identifier hs-type">uInfixT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165419"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165419"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165419"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165419"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-688"></span><span id="uInfixT"><span class="annot"><span class="annottext">uInfixT :: forall (m :: * -&gt; *). Quote m =&gt; m Type -&gt; Name -&gt; m Type -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#uInfixT"><span class="hs-identifier hs-var hs-var">uInfixT</span></a></span></span><span> </span><span id="local-6989586621679165411"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165411"><span class="hs-identifier hs-var">t1</span></a></span></span><span> </span><span id="local-6989586621679165410"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165410"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679165409"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165409"><span class="hs-identifier hs-var">t2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679165408"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165408"><span class="hs-identifier hs-var">t1'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165411"><span class="hs-identifier hs-var">t1</span></a></span><span>
</span><span id="line-689"></span><span>                     </span><span id="local-6989586621679165407"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165407"><span class="hs-identifier hs-var">t2'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165409"><span class="hs-identifier hs-var">t2</span></a></span><span>
</span><span id="line-690"></span><span>                     </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Type -&gt; Name -&gt; Type -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#UInfixT"><span class="hs-identifier hs-var">UInfixT</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165408"><span class="hs-identifier hs-var">t1'</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165410"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165407"><span class="hs-identifier hs-var">t2'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-691"></span><span>
</span><span id="line-692"></span><span id="local-6989586621679167001"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#parensT"><span class="hs-identifier hs-type">parensT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167001"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167001"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167001"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-693"></span><span id="parensT"><span class="annot"><span class="annottext">parensT :: forall (m :: * -&gt; *). Quote m =&gt; m Type -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#parensT"><span class="hs-identifier hs-var hs-var">parensT</span></a></span></span><span> </span><span id="local-6989586621679165399"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165399"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679165398"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165398"><span class="hs-identifier hs-var">t'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165399"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-694"></span><span>               </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Type -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#ParensT"><span class="hs-identifier hs-var">ParensT</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165398"><span class="hs-identifier hs-var">t'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-695"></span><span>
</span><span id="line-696"></span><span id="local-6989586621679166999"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#appT"><span class="hs-identifier hs-type">appT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166999"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166999"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166999"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166999"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-697"></span><span id="appT"><span class="annot"><span class="annottext">appT :: forall (m :: * -&gt; *). Quote m =&gt; m Type -&gt; m Type -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#appT"><span class="hs-identifier hs-var hs-var">appT</span></a></span></span><span> </span><span id="local-6989586621679165390"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165390"><span class="hs-identifier hs-var">t1</span></a></span></span><span> </span><span id="local-6989586621679165389"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165389"><span class="hs-identifier hs-var">t2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-698"></span><span>           </span><span id="local-6989586621679165388"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165388"><span class="hs-identifier hs-var">t1'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165390"><span class="hs-identifier hs-var">t1</span></a></span><span>
</span><span id="line-699"></span><span>           </span><span id="local-6989586621679165387"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165387"><span class="hs-identifier hs-var">t2'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165389"><span class="hs-identifier hs-var">t2</span></a></span><span>
</span><span id="line-700"></span><span>           </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Type -&gt; m Type) -&gt; Type -&gt; m Type
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#AppT"><span class="hs-identifier hs-var">AppT</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165388"><span class="hs-identifier hs-var">t1'</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165387"><span class="hs-identifier hs-var">t2'</span></a></span><span>
</span><span id="line-701"></span><span>
</span><span id="line-702"></span><span id="local-6989586621679165385"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#appKindT"><span class="hs-identifier hs-type">appKindT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165385"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165385"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165385"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165385"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-703"></span><span id="appKindT"><span class="annot"><span class="annottext">appKindT :: forall (m :: * -&gt; *). Quote m =&gt; m Type -&gt; m Type -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#appKindT"><span class="hs-identifier hs-var hs-var">appKindT</span></a></span></span><span> </span><span id="local-6989586621679165378"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165378"><span class="hs-identifier hs-var">ty</span></a></span></span><span> </span><span id="local-6989586621679165377"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165377"><span class="hs-identifier hs-var">ki</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-704"></span><span>               </span><span id="local-6989586621679165376"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165376"><span class="hs-identifier hs-var">ty'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165378"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-705"></span><span>               </span><span id="local-6989586621679165375"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165375"><span class="hs-identifier hs-var">ki'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165377"><span class="hs-identifier hs-var">ki</span></a></span><span>
</span><span id="line-706"></span><span>               </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Type -&gt; m Type) -&gt; Type -&gt; m Type
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#AppKindT"><span class="hs-identifier hs-var">AppKindT</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165376"><span class="hs-identifier hs-var">ty'</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165375"><span class="hs-identifier hs-var">ki'</span></a></span><span>
</span><span id="line-707"></span><span>
</span><span id="line-708"></span><span id="local-6989586621679166996"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#arrowT"><span class="hs-identifier hs-type">arrowT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166996"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166996"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-709"></span><span id="arrowT"><span class="annot"><span class="annottext">arrowT :: forall (m :: * -&gt; *). Quote m =&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#arrowT"><span class="hs-identifier hs-var hs-var">arrowT</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="Language.Haskell.TH.Syntax.html#ArrowT"><span class="hs-identifier hs-var">ArrowT</span></a></span><span>
</span><span id="line-710"></span><span>
</span><span id="line-711"></span><span id="local-6989586621679165368"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#mulArrowT"><span class="hs-identifier hs-type">mulArrowT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165368"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165368"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-712"></span><span id="mulArrowT"><span class="annot"><span class="annottext">mulArrowT :: forall (m :: * -&gt; *). Quote m =&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#mulArrowT"><span class="hs-identifier hs-var hs-var">mulArrowT</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="Language.Haskell.TH.Syntax.html#MulArrowT"><span class="hs-identifier hs-var">MulArrowT</span></a></span><span>
</span><span id="line-713"></span><span>
</span><span id="line-714"></span><span id="local-6989586621679165362"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#listT"><span class="hs-identifier hs-type">listT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165362"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165362"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-715"></span><span id="listT"><span class="annot"><span class="annottext">listT :: forall (m :: * -&gt; *). Quote m =&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#listT"><span class="hs-identifier hs-var hs-var">listT</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="Language.Haskell.TH.Syntax.html#ListT"><span class="hs-identifier hs-var">ListT</span></a></span><span>
</span><span id="line-716"></span><span>
</span><span id="line-717"></span><span id="local-6989586621679166992"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#litT"><span class="hs-identifier hs-type">litT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166992"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166992"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyLit"><span class="hs-identifier hs-type">TyLit</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166992"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-718"></span><span id="litT"><span class="annot"><span class="annottext">litT :: forall (m :: * -&gt; *). Quote m =&gt; m TyLit -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#litT"><span class="hs-identifier hs-var hs-var">litT</span></a></span></span><span> </span><span id="local-6989586621679165351"><span class="annot"><span class="annottext">m TyLit
</span><a href="#local-6989586621679165351"><span class="hs-identifier hs-var">l</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(TyLit -&gt; Type) -&gt; m TyLit -&gt; m Type
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">TyLit -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#LitT"><span class="hs-identifier hs-var">LitT</span></a></span><span> </span><span class="annot"><span class="annottext">m TyLit
</span><a href="#local-6989586621679165351"><span class="hs-identifier hs-var">l</span></a></span><span>
</span><span id="line-719"></span><span>
</span><span id="line-720"></span><span id="local-6989586621679166989"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tupleT"><span class="hs-identifier hs-type">tupleT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166989"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166989"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-721"></span><span id="tupleT"><span class="annot"><span class="annottext">tupleT :: forall (m :: * -&gt; *). Quote m =&gt; SumAlt -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#tupleT"><span class="hs-identifier hs-var hs-var">tupleT</span></a></span></span><span> </span><span id="local-6989586621679165345"><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679165345"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SumAlt -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#TupleT"><span class="hs-identifier hs-var">TupleT</span></a></span><span> </span><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679165345"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-722"></span><span>
</span><span id="line-723"></span><span id="local-6989586621679165343"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unboxedTupleT"><span class="hs-identifier hs-type">unboxedTupleT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165343"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165343"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-724"></span><span id="unboxedTupleT"><span class="annot"><span class="annottext">unboxedTupleT :: forall (m :: * -&gt; *). Quote m =&gt; SumAlt -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#unboxedTupleT"><span class="hs-identifier hs-var hs-var">unboxedTupleT</span></a></span></span><span> </span><span id="local-6989586621679165338"><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679165338"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SumAlt -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#UnboxedTupleT"><span class="hs-identifier hs-var">UnboxedTupleT</span></a></span><span> </span><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679165338"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-725"></span><span>
</span><span id="line-726"></span><span id="local-6989586621679165336"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unboxedSumT"><span class="hs-identifier hs-type">unboxedSumT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165336"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#SumArity"><span class="hs-identifier hs-type">SumArity</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165336"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-727"></span><span id="unboxedSumT"><span class="annot"><span class="annottext">unboxedSumT :: forall (m :: * -&gt; *). Quote m =&gt; SumAlt -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#unboxedSumT"><span class="hs-identifier hs-var hs-var">unboxedSumT</span></a></span></span><span> </span><span id="local-6989586621679165331"><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679165331"><span class="hs-identifier hs-var">arity</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SumAlt -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#UnboxedSumT"><span class="hs-identifier hs-var">UnboxedSumT</span></a></span><span> </span><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679165331"><span class="hs-identifier hs-var">arity</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-728"></span><span>
</span><span id="line-729"></span><span id="local-6989586621679165329"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sigT"><span class="hs-identifier hs-type">sigT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165329"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165329"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165329"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165329"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-730"></span><span id="sigT"><span class="annot"><span class="annottext">sigT :: forall (m :: * -&gt; *). Quote m =&gt; m Type -&gt; m Type -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#sigT"><span class="hs-identifier hs-var hs-var">sigT</span></a></span></span><span> </span><span id="local-6989586621679165322"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165322"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span id="local-6989586621679165321"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165321"><span class="hs-identifier hs-var">k</span></a></span></span><span>
</span><span id="line-731"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-732"></span><span>      </span><span id="local-6989586621679165320"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165320"><span class="hs-identifier hs-var">t'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165322"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-733"></span><span>      </span><span id="local-6989586621679165319"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165319"><span class="hs-identifier hs-var">k'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165321"><span class="hs-identifier hs-var">k</span></a></span><span>
</span><span id="line-734"></span><span>      </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Type -&gt; m Type) -&gt; Type -&gt; m Type
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#SigT"><span class="hs-identifier hs-var">SigT</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165320"><span class="hs-identifier hs-var">t'</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165319"><span class="hs-identifier hs-var">k'</span></a></span><span>
</span><span id="line-735"></span><span>
</span><span id="line-736"></span><span id="local-6989586621679165317"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#equalityT"><span class="hs-identifier hs-type">equalityT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165317"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165317"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-737"></span><span id="equalityT"><span class="annot"><span class="annottext">equalityT :: forall (m :: * -&gt; *). Quote m =&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#equalityT"><span class="hs-identifier hs-var hs-var">equalityT</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="Language.Haskell.TH.Syntax.html#EqualityT"><span class="hs-identifier hs-var">EqualityT</span></a></span><span>
</span><span id="line-738"></span><span>
</span><span id="line-739"></span><span id="local-6989586621679165311"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#wildCardT"><span class="hs-identifier hs-type">wildCardT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165311"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165311"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-740"></span><span id="wildCardT"><span class="annot"><span class="annottext">wildCardT :: forall (m :: * -&gt; *). Quote m =&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#wildCardT"><span class="hs-identifier hs-var hs-var">wildCardT</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="Language.Haskell.TH.Syntax.html#WildCardT"><span class="hs-identifier hs-var">WildCardT</span></a></span><span>
</span><span id="line-741"></span><span>
</span><span id="line-742"></span><span id="local-6989586621679166982"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#implicitParamT"><span class="hs-identifier hs-type">implicitParamT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166982"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166982"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166982"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-743"></span><span id="implicitParamT"><span class="annot"><span class="annottext">implicitParamT :: forall (m :: * -&gt; *). Quote m =&gt; String -&gt; m Type -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#implicitParamT"><span class="hs-identifier hs-var hs-var">implicitParamT</span></a></span></span><span> </span><span id="local-6989586621679165300"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679165300"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679165299"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165299"><span class="hs-identifier hs-var">t</span></a></span></span><span>
</span><span id="line-744"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-745"></span><span>      </span><span id="local-6989586621679165298"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165298"><span class="hs-identifier hs-var">t'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165299"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-746"></span><span>      </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Type -&gt; m Type) -&gt; Type -&gt; m Type
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; Type -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#ImplicitParamT"><span class="hs-identifier hs-var">ImplicitParamT</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679165300"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165298"><span class="hs-identifier hs-var">t'</span></a></span><span>
</span><span id="line-747"></span><span>
</span><span id="line-748"></span><span class="hs-pragma">{-# DEPRECATED</span><span> </span><span class="hs-pragma">classP</span><span> </span><span class="hs-pragma">&quot;As of template-haskell-2.10, constraint predicates (Pred) are just types (Type), in keeping with ConstraintKinds. Please use 'conT' and 'appT'.&quot;</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-749"></span><span id="local-6989586621679166980"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#classP"><span class="hs-identifier hs-type">classP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166980"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679166980"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166980"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pred"><span class="hs-identifier hs-type">Pred</span></a></span></span><span>
</span><span id="line-750"></span><span id="classP"><span class="annot"><span class="annottext">classP :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; [m Type] -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#classP"><span class="hs-identifier hs-var hs-var">classP</span></a></span></span><span> </span><span id="local-6989586621679165286"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165286"><span class="hs-identifier hs-var">cla</span></a></span></span><span> </span><span id="local-6989586621679165285"><span class="annot"><span class="annottext">[m Type]
</span><a href="#local-6989586621679165285"><span class="hs-identifier hs-var">tys</span></a></span></span><span>
</span><span id="line-751"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-752"></span><span>      </span><span id="local-6989586621679165284"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165284"><span class="hs-identifier hs-var">tysl</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Type] -&gt; m Cxt
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Type]
</span><a href="#local-6989586621679165285"><span class="hs-identifier hs-var">tys</span></a></span><span>
</span><span id="line-753"></span><span>      </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Type -&gt; Type -&gt; Type) -&gt; Type -&gt; Cxt -&gt; Type
forall (t :: * -&gt; *) b a.
Foldable t =&gt;
(b -&gt; a -&gt; b) -&gt; b -&gt; t a -&gt; b
</span><a href="../../base/src/Data.Foldable.html#foldl"><span class="hs-identifier hs-var">foldl</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#AppT"><span class="hs-identifier hs-var">AppT</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#ConT"><span class="hs-identifier hs-var">ConT</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165286"><span class="hs-identifier hs-var">cla</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679165284"><span class="hs-identifier hs-var">tysl</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-754"></span><span>
</span><span id="line-755"></span><span class="hs-pragma">{-# DEPRECATED</span><span> </span><span class="hs-pragma">equalP</span><span> </span><span class="hs-pragma">&quot;As of template-haskell-2.10, constraint predicates (Pred) are just types (Type), in keeping with ConstraintKinds. Please see 'equalityT'.&quot;</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-756"></span><span id="local-6989586621679165282"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#equalP"><span class="hs-identifier hs-type">equalP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165282"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165282"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165282"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165282"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pred"><span class="hs-identifier hs-type">Pred</span></a></span></span><span>
</span><span id="line-757"></span><span id="equalP"><span class="annot"><span class="annottext">equalP :: forall (m :: * -&gt; *). Quote m =&gt; m Type -&gt; m Type -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#equalP"><span class="hs-identifier hs-var hs-var">equalP</span></a></span></span><span> </span><span id="local-6989586621679165271"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165271"><span class="hs-identifier hs-var">tleft</span></a></span></span><span> </span><span id="local-6989586621679165270"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165270"><span class="hs-identifier hs-var">tright</span></a></span></span><span>
</span><span id="line-758"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-759"></span><span>      </span><span id="local-6989586621679165269"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165269"><span class="hs-identifier hs-var">tleft1</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165271"><span class="hs-identifier hs-var">tleft</span></a></span><span>
</span><span id="line-760"></span><span>      </span><span id="local-6989586621679165268"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165268"><span class="hs-identifier hs-var">tright1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165270"><span class="hs-identifier hs-var">tright</span></a></span><span>
</span><span id="line-761"></span><span>      </span><span id="local-6989586621679165267"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165267"><span class="hs-identifier hs-var">eqT</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
forall (m :: * -&gt; *). Quote m =&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#equalityT"><span class="hs-identifier hs-var">equalityT</span></a></span><span>
</span><span id="line-762"></span><span>      </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Type -&gt; Type -&gt; Type) -&gt; Type -&gt; Cxt -&gt; Type
forall (t :: * -&gt; *) b a.
Foldable t =&gt;
(b -&gt; a -&gt; b) -&gt; b -&gt; t a -&gt; b
</span><a href="../../base/src/Data.Foldable.html#foldl"><span class="hs-identifier hs-var">foldl</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#AppT"><span class="hs-identifier hs-var">AppT</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165267"><span class="hs-identifier hs-var">eqT</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165269"><span class="hs-identifier hs-var">tleft1</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165268"><span class="hs-identifier hs-var">tright1</span></a></span><span class="hs-special">]</span><span class="hs-special">)</span><span>
</span><span id="line-763"></span><span>
</span><span id="line-764"></span><span id="local-6989586621679165266"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#promotedT"><span class="hs-identifier hs-type">promotedT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165266"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165266"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-765"></span><span id="promotedT"><span class="annot"><span class="annottext">promotedT :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#promotedT"><span class="hs-identifier hs-var hs-var">promotedT</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Type -&gt; m Type) -&gt; (Name -&gt; Type) -&gt; Name -&gt; m Type
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Name -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#PromotedT"><span class="hs-identifier hs-var">PromotedT</span></a></span><span>
</span><span id="line-766"></span><span>
</span><span id="line-767"></span><span id="local-6989586621679165260"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#promotedTupleT"><span class="hs-identifier hs-type">promotedTupleT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165260"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165260"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-768"></span><span id="promotedTupleT"><span class="annot"><span class="annottext">promotedTupleT :: forall (m :: * -&gt; *). Quote m =&gt; SumAlt -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#promotedTupleT"><span class="hs-identifier hs-var hs-var">promotedTupleT</span></a></span></span><span> </span><span id="local-6989586621679165255"><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679165255"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SumAlt -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#PromotedTupleT"><span class="hs-identifier hs-var">PromotedTupleT</span></a></span><span> </span><span class="annot"><span class="annottext">SumAlt
</span><a href="#local-6989586621679165255"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-769"></span><span>
</span><span id="line-770"></span><span id="local-6989586621679165253"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#promotedNilT"><span class="hs-identifier hs-type">promotedNilT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165253"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165253"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-771"></span><span id="promotedNilT"><span class="annot"><span class="annottext">promotedNilT :: forall (m :: * -&gt; *). Quote m =&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#promotedNilT"><span class="hs-identifier hs-var hs-var">promotedNilT</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="Language.Haskell.TH.Syntax.html#PromotedNilT"><span class="hs-identifier hs-var">PromotedNilT</span></a></span><span>
</span><span id="line-772"></span><span>
</span><span id="line-773"></span><span id="local-6989586621679165247"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#promotedConsT"><span class="hs-identifier hs-type">promotedConsT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165247"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165247"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-774"></span><span id="promotedConsT"><span class="annot"><span class="annottext">promotedConsT :: forall (m :: * -&gt; *). Quote m =&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#promotedConsT"><span class="hs-identifier hs-var hs-var">promotedConsT</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="Language.Haskell.TH.Syntax.html#PromotedConsT"><span class="hs-identifier hs-var">PromotedConsT</span></a></span><span>
</span><span id="line-775"></span><span>
</span><span id="line-776"></span><span id="local-6989586621679166970"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#noSourceUnpackedness"><span class="hs-identifier hs-type">noSourceUnpackedness</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sourceNoUnpack"><span class="hs-identifier hs-type">sourceNoUnpack</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sourceUnpack"><span class="hs-identifier hs-type">sourceUnpack</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166970"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166970"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#SourceUnpackedness"><span class="hs-identifier hs-type">SourceUnpackedness</span></a></span></span><span>
</span><span id="line-777"></span><span id="noSourceUnpackedness"><span class="annot"><span class="annottext">noSourceUnpackedness :: forall (m :: * -&gt; *). Quote m =&gt; m SourceUnpackedness
</span><a href="Language.Haskell.TH.Lib.Internal.html#noSourceUnpackedness"><span class="hs-identifier hs-var hs-var">noSourceUnpackedness</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">SourceUnpackedness -&gt; m SourceUnpackedness
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">SourceUnpackedness
</span><a href="Language.Haskell.TH.Syntax.html#NoSourceUnpackedness"><span class="hs-identifier hs-var">NoSourceUnpackedness</span></a></span><span>
</span><span id="line-778"></span><span id="sourceNoUnpack"><span class="annot"><span class="annottext">sourceNoUnpack :: forall (m :: * -&gt; *). Quote m =&gt; m SourceUnpackedness
</span><a href="Language.Haskell.TH.Lib.Internal.html#sourceNoUnpack"><span class="hs-identifier hs-var hs-var">sourceNoUnpack</span></a></span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">SourceUnpackedness -&gt; m SourceUnpackedness
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">SourceUnpackedness
</span><a href="Language.Haskell.TH.Syntax.html#SourceNoUnpack"><span class="hs-identifier hs-var">SourceNoUnpack</span></a></span><span>
</span><span id="line-779"></span><span id="sourceUnpack"><span class="annot"><span class="annottext">sourceUnpack :: forall (m :: * -&gt; *). Quote m =&gt; m SourceUnpackedness
</span><a href="Language.Haskell.TH.Lib.Internal.html#sourceUnpack"><span class="hs-identifier hs-var hs-var">sourceUnpack</span></a></span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">SourceUnpackedness -&gt; m SourceUnpackedness
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">SourceUnpackedness
</span><a href="Language.Haskell.TH.Syntax.html#SourceUnpack"><span class="hs-identifier hs-var">SourceUnpack</span></a></span><span>
</span><span id="line-780"></span><span>
</span><span id="line-781"></span><span id="local-6989586621679166965"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#noSourceStrictness"><span class="hs-identifier hs-type">noSourceStrictness</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sourceLazy"><span class="hs-identifier hs-type">sourceLazy</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sourceStrict"><span class="hs-identifier hs-type">sourceStrict</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166965"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166965"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#SourceStrictness"><span class="hs-identifier hs-type">SourceStrictness</span></a></span></span><span>
</span><span id="line-782"></span><span id="noSourceStrictness"><span class="annot"><span class="annottext">noSourceStrictness :: forall (m :: * -&gt; *). Quote m =&gt; m SourceStrictness
</span><a href="Language.Haskell.TH.Lib.Internal.html#noSourceStrictness"><span class="hs-identifier hs-var hs-var">noSourceStrictness</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">SourceStrictness -&gt; m SourceStrictness
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">SourceStrictness
</span><a href="Language.Haskell.TH.Syntax.html#NoSourceStrictness"><span class="hs-identifier hs-var">NoSourceStrictness</span></a></span><span>
</span><span id="line-783"></span><span id="sourceLazy"><span class="annot"><span class="annottext">sourceLazy :: forall (m :: * -&gt; *). Quote m =&gt; m SourceStrictness
</span><a href="Language.Haskell.TH.Lib.Internal.html#sourceLazy"><span class="hs-identifier hs-var hs-var">sourceLazy</span></a></span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">SourceStrictness -&gt; m SourceStrictness
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">SourceStrictness
</span><a href="Language.Haskell.TH.Syntax.html#SourceLazy"><span class="hs-identifier hs-var">SourceLazy</span></a></span><span>
</span><span id="line-784"></span><span id="sourceStrict"><span class="annot"><span class="annottext">sourceStrict :: forall (m :: * -&gt; *). Quote m =&gt; m SourceStrictness
</span><a href="Language.Haskell.TH.Lib.Internal.html#sourceStrict"><span class="hs-identifier hs-var hs-var">sourceStrict</span></a></span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">SourceStrictness -&gt; m SourceStrictness
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">SourceStrictness
</span><a href="Language.Haskell.TH.Syntax.html#SourceStrict"><span class="hs-identifier hs-var">SourceStrict</span></a></span><span>
</span><span id="line-785"></span><span>
</span><span id="line-786"></span><span class="hs-pragma">{-# DEPRECATED</span><span> </span><span class="hs-pragma">isStrict</span><span>
</span><span id="line-787"></span><span>    </span><span class="hs-pragma">[</span><span class="hs-pragma">&quot;Use 'bang'. See https://gitlab.haskell.org/ghc/ghc/wikis/migration/8.0. &quot;</span><span class="hs-pragma">,</span><span>
</span><span id="line-788"></span><span>     </span><span class="hs-pragma">&quot;Example usage: 'bang noSourceUnpackedness sourceStrict'&quot;</span><span class="hs-pragma">]</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-789"></span><span class="hs-pragma">{-# DEPRECATED</span><span> </span><span class="hs-pragma">notStrict</span><span>
</span><span id="line-790"></span><span>    </span><span class="hs-pragma">[</span><span class="hs-pragma">&quot;Use 'bang'. See https://gitlab.haskell.org/ghc/ghc/wikis/migration/8.0. &quot;</span><span class="hs-pragma">,</span><span>
</span><span id="line-791"></span><span>     </span><span class="hs-pragma">&quot;Example usage: 'bang noSourceUnpackedness noSourceStrictness'&quot;</span><span class="hs-pragma">]</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-792"></span><span class="hs-pragma">{-# DEPRECATED</span><span> </span><span class="hs-pragma">unpacked</span><span>
</span><span id="line-793"></span><span>    </span><span class="hs-pragma">[</span><span class="hs-pragma">&quot;Use 'bang'. See https://gitlab.haskell.org/ghc/ghc/wikis/migration/8.0. &quot;</span><span class="hs-pragma">,</span><span>
</span><span id="line-794"></span><span>     </span><span class="hs-pragma">&quot;Example usage: 'bang sourceUnpack sourceStrict'&quot;</span><span class="hs-pragma">]</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-795"></span><span id="local-6989586621679166960"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#isStrict"><span class="hs-identifier hs-type">isStrict</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#notStrict"><span class="hs-identifier hs-type">notStrict</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unpacked"><span class="hs-identifier hs-type">unpacked</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166960"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166960"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Strict"><span class="hs-identifier hs-type">Strict</span></a></span></span><span>
</span><span id="line-796"></span><span id="isStrict"><span class="annot"><span class="annottext">isStrict :: forall (m :: * -&gt; *). Quote m =&gt; m Strict
</span><a href="Language.Haskell.TH.Lib.Internal.html#isStrict"><span class="hs-identifier hs-var hs-var">isStrict</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m SourceUnpackedness -&gt; m SourceStrictness -&gt; m Strict
forall (m :: * -&gt; *).
Quote m =&gt;
m SourceUnpackedness -&gt; m SourceStrictness -&gt; m Strict
</span><a href="Language.Haskell.TH.Lib.Internal.html#bang"><span class="hs-identifier hs-var">bang</span></a></span><span> </span><span class="annot"><span class="annottext">m SourceUnpackedness
forall (m :: * -&gt; *). Quote m =&gt; m SourceUnpackedness
</span><a href="Language.Haskell.TH.Lib.Internal.html#noSourceUnpackedness"><span class="hs-identifier hs-var">noSourceUnpackedness</span></a></span><span> </span><span class="annot"><span class="annottext">m SourceStrictness
forall (m :: * -&gt; *). Quote m =&gt; m SourceStrictness
</span><a href="Language.Haskell.TH.Lib.Internal.html#sourceStrict"><span class="hs-identifier hs-var">sourceStrict</span></a></span><span>
</span><span id="line-797"></span><span id="notStrict"><span class="annot"><span class="annottext">notStrict :: forall (m :: * -&gt; *). Quote m =&gt; m Strict
</span><a href="Language.Haskell.TH.Lib.Internal.html#notStrict"><span class="hs-identifier hs-var hs-var">notStrict</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m SourceUnpackedness -&gt; m SourceStrictness -&gt; m Strict
forall (m :: * -&gt; *).
Quote m =&gt;
m SourceUnpackedness -&gt; m SourceStrictness -&gt; m Strict
</span><a href="Language.Haskell.TH.Lib.Internal.html#bang"><span class="hs-identifier hs-var">bang</span></a></span><span> </span><span class="annot"><span class="annottext">m SourceUnpackedness
forall (m :: * -&gt; *). Quote m =&gt; m SourceUnpackedness
</span><a href="Language.Haskell.TH.Lib.Internal.html#noSourceUnpackedness"><span class="hs-identifier hs-var">noSourceUnpackedness</span></a></span><span> </span><span class="annot"><span class="annottext">m SourceStrictness
forall (m :: * -&gt; *). Quote m =&gt; m SourceStrictness
</span><a href="Language.Haskell.TH.Lib.Internal.html#noSourceStrictness"><span class="hs-identifier hs-var">noSourceStrictness</span></a></span><span>
</span><span id="line-798"></span><span id="unpacked"><span class="annot"><span class="annottext">unpacked :: forall (m :: * -&gt; *). Quote m =&gt; m Strict
</span><a href="Language.Haskell.TH.Lib.Internal.html#unpacked"><span class="hs-identifier hs-var hs-var">unpacked</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m SourceUnpackedness -&gt; m SourceStrictness -&gt; m Strict
forall (m :: * -&gt; *).
Quote m =&gt;
m SourceUnpackedness -&gt; m SourceStrictness -&gt; m Strict
</span><a href="Language.Haskell.TH.Lib.Internal.html#bang"><span class="hs-identifier hs-var">bang</span></a></span><span> </span><span class="annot"><span class="annottext">m SourceUnpackedness
forall (m :: * -&gt; *). Quote m =&gt; m SourceUnpackedness
</span><a href="Language.Haskell.TH.Lib.Internal.html#sourceUnpack"><span class="hs-identifier hs-var">sourceUnpack</span></a></span><span> </span><span class="annot"><span class="annottext">m SourceStrictness
forall (m :: * -&gt; *). Quote m =&gt; m SourceStrictness
</span><a href="Language.Haskell.TH.Lib.Internal.html#sourceStrict"><span class="hs-identifier hs-var">sourceStrict</span></a></span><span>
</span><span id="line-799"></span><span>
</span><span id="line-800"></span><span id="local-6989586621679166957"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#bang"><span class="hs-identifier hs-type">bang</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166957"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166957"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#SourceUnpackedness"><span class="hs-identifier hs-type">SourceUnpackedness</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166957"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#SourceStrictness"><span class="hs-identifier hs-type">SourceStrictness</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166957"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Bang"><span class="hs-identifier hs-type">Bang</span></a></span></span><span>
</span><span id="line-801"></span><span id="bang"><span class="annot"><span class="annottext">bang :: forall (m :: * -&gt; *).
Quote m =&gt;
m SourceUnpackedness -&gt; m SourceStrictness -&gt; m Strict
</span><a href="Language.Haskell.TH.Lib.Internal.html#bang"><span class="hs-identifier hs-var hs-var">bang</span></a></span></span><span> </span><span id="local-6989586621679165190"><span class="annot"><span class="annottext">m SourceUnpackedness
</span><a href="#local-6989586621679165190"><span class="hs-identifier hs-var">u</span></a></span></span><span> </span><span id="local-6989586621679165189"><span class="annot"><span class="annottext">m SourceStrictness
</span><a href="#local-6989586621679165189"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679165188"><span class="annot"><span class="annottext">SourceUnpackedness
</span><a href="#local-6989586621679165188"><span class="hs-identifier hs-var">u'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m SourceUnpackedness
</span><a href="#local-6989586621679165190"><span class="hs-identifier hs-var">u</span></a></span><span>
</span><span id="line-802"></span><span>              </span><span id="local-6989586621679165187"><span class="annot"><span class="annottext">SourceStrictness
</span><a href="#local-6989586621679165187"><span class="hs-identifier hs-var">s'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m SourceStrictness
</span><a href="#local-6989586621679165189"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-803"></span><span>              </span><span class="annot"><span class="annottext">Strict -&gt; m Strict
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SourceUnpackedness -&gt; SourceStrictness -&gt; Strict
</span><a href="Language.Haskell.TH.Syntax.html#Bang"><span class="hs-identifier hs-var">Bang</span></a></span><span> </span><span class="annot"><span class="annottext">SourceUnpackedness
</span><a href="#local-6989586621679165188"><span class="hs-identifier hs-var">u'</span></a></span><span> </span><span class="annot"><span class="annottext">SourceStrictness
</span><a href="#local-6989586621679165187"><span class="hs-identifier hs-var">s'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-804"></span><span>
</span><span id="line-805"></span><span id="local-6989586621679166953"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#bangType"><span class="hs-identifier hs-type">bangType</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166953"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166953"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Bang"><span class="hs-identifier hs-type">Bang</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166953"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166953"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#BangType"><span class="hs-identifier hs-type">BangType</span></a></span></span><span>
</span><span id="line-806"></span><span id="bangType"><span class="annot"><span class="annottext">bangType :: forall (m :: * -&gt; *). Quote m =&gt; m Strict -&gt; m Type -&gt; m BangType
</span><a href="Language.Haskell.TH.Lib.Internal.html#bangType"><span class="hs-identifier hs-var hs-var">bangType</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Strict -&gt; Type -&gt; BangType) -&gt; m Strict -&gt; m Type -&gt; m BangType
forall (f :: * -&gt; *) a b c.
Applicative f =&gt;
(a -&gt; b -&gt; c) -&gt; f a -&gt; f b -&gt; f c
</span><a href="../../base/src/GHC.Base.html#liftA2"><span class="hs-identifier hs-var">liftA2</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">,</span><span class="hs-special">)</span><span>
</span><span id="line-807"></span><span>
</span><span id="line-808"></span><span id="local-6989586621679166950"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#varBangType"><span class="hs-identifier hs-type">varBangType</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166950"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166950"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#BangType"><span class="hs-identifier hs-type">BangType</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166950"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#VarBangType"><span class="hs-identifier hs-type">VarBangType</span></a></span></span><span>
</span><span id="line-809"></span><span id="varBangType"><span class="annot"><span class="annottext">varBangType :: forall (m :: * -&gt; *).
Quote m =&gt;
Name -&gt; m BangType -&gt; m VarBangType
</span><a href="Language.Haskell.TH.Lib.Internal.html#varBangType"><span class="hs-identifier hs-var hs-var">varBangType</span></a></span></span><span> </span><span id="local-6989586621679165176"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165176"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span id="local-6989586621679165175"><span class="annot"><span class="annottext">m BangType
</span><a href="#local-6989586621679165175"><span class="hs-identifier hs-var">bt</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span class="hs-special">(</span><span id="local-6989586621679165174"><span class="annot"><span class="annottext">Strict
</span><a href="#local-6989586621679165174"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679165173"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165173"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165176"><span class="hs-identifier hs-var">v</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Strict
</span><a href="#local-6989586621679165174"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679165173"><span class="hs-identifier hs-var">t</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(BangType -&gt; VarBangType) -&gt; m BangType -&gt; m VarBangType
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m BangType
</span><a href="#local-6989586621679165175"><span class="hs-identifier hs-var">bt</span></a></span><span>
</span><span id="line-810"></span><span>
</span><span id="line-811"></span><span class="hs-pragma">{-# DEPRECATED</span><span> </span><span class="hs-pragma">strictType</span><span>
</span><span id="line-812"></span><span>               </span><span class="hs-pragma">&quot;As of @template-haskell-2.11.0.0@, 'StrictType' has been replaced by 'BangType'. Please use 'bangType' instead.&quot;</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-813"></span><span id="local-6989586621679165172"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#strictType"><span class="hs-identifier hs-type">strictType</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165172"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165172"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Strict"><span class="hs-identifier hs-type">Strict</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165172"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165172"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#StrictType"><span class="hs-identifier hs-type">StrictType</span></a></span></span><span>
</span><span id="line-814"></span><span id="strictType"><span class="annot"><span class="annottext">strictType :: forall (m :: * -&gt; *). Quote m =&gt; m Strict -&gt; m Type -&gt; m BangType
</span><a href="Language.Haskell.TH.Lib.Internal.html#strictType"><span class="hs-identifier hs-var hs-var">strictType</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Strict -&gt; m Type -&gt; m BangType
forall (m :: * -&gt; *). Quote m =&gt; m Strict -&gt; m Type -&gt; m BangType
</span><a href="Language.Haskell.TH.Lib.Internal.html#bangType"><span class="hs-identifier hs-var">bangType</span></a></span><span>
</span><span id="line-815"></span><span>
</span><span id="line-816"></span><span class="hs-pragma">{-# DEPRECATED</span><span> </span><span class="hs-pragma">varStrictType</span><span>
</span><span id="line-817"></span><span>               </span><span class="hs-pragma">&quot;As of @template-haskell-2.11.0.0@, 'VarStrictType' has been replaced by 'VarBangType'. Please use 'varBangType' instead.&quot;</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-818"></span><span id="local-6989586621679165168"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#varStrictType"><span class="hs-identifier hs-type">varStrictType</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165168"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165168"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#StrictType"><span class="hs-identifier hs-type">StrictType</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165168"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#VarStrictType"><span class="hs-identifier hs-type">VarStrictType</span></a></span></span><span>
</span><span id="line-819"></span><span id="varStrictType"><span class="annot"><span class="annottext">varStrictType :: forall (m :: * -&gt; *).
Quote m =&gt;
Name -&gt; m BangType -&gt; m VarBangType
</span><a href="Language.Haskell.TH.Lib.Internal.html#varStrictType"><span class="hs-identifier hs-var hs-var">varStrictType</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name -&gt; m BangType -&gt; m VarBangType
forall (m :: * -&gt; *).
Quote m =&gt;
Name -&gt; m BangType -&gt; m VarBangType
</span><a href="Language.Haskell.TH.Lib.Internal.html#varBangType"><span class="hs-identifier hs-var">varBangType</span></a></span><span>
</span><span id="line-820"></span><span>
</span><span id="line-821"></span><span class="hs-comment">-- * Type Literals</span><span>
</span><span id="line-822"></span><span>
</span><span id="line-823"></span><span class="hs-comment">-- MonadFail here complicates things (a lot) because it would mean we would</span><span>
</span><span id="line-824"></span><span class="hs-comment">-- have to emit a MonadFail constraint during typechecking if there was any</span><span>
</span><span id="line-825"></span><span class="hs-comment">-- chance the desugaring would use numTyLit, which in general is hard to</span><span>
</span><span id="line-826"></span><span class="hs-comment">-- predict.</span><span>
</span><span id="line-827"></span><span id="local-6989586621679166946"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#numTyLit"><span class="hs-identifier hs-type">numTyLit</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166946"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166946"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyLit"><span class="hs-identifier hs-type">TyLit</span></a></span></span><span>
</span><span id="line-828"></span><span id="numTyLit"><span class="annot"><span class="annottext">numTyLit :: forall (m :: * -&gt; *). Quote m =&gt; Integer -&gt; m TyLit
</span><a href="Language.Haskell.TH.Lib.Internal.html#numTyLit"><span class="hs-identifier hs-var hs-var">numTyLit</span></a></span></span><span> </span><span id="local-6989586621679165152"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679165152"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679165152"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">TyLit -&gt; m TyLit
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; TyLit
</span><a href="Language.Haskell.TH.Syntax.html#NumTyLit"><span class="hs-identifier hs-var">NumTyLit</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679165152"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-829"></span><span>                       </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">String -&gt; m TyLit
forall a. HasCallStack =&gt; String -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Negative type-level number: &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679165152"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-830"></span><span>
</span><span id="line-831"></span><span id="local-6989586621679166938"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#strTyLit"><span class="hs-identifier hs-type">strTyLit</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166938"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166938"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyLit"><span class="hs-identifier hs-type">TyLit</span></a></span></span><span>
</span><span id="line-832"></span><span id="strTyLit"><span class="annot"><span class="annottext">strTyLit :: forall (m :: * -&gt; *). Quote m =&gt; String -&gt; m TyLit
</span><a href="Language.Haskell.TH.Lib.Internal.html#strTyLit"><span class="hs-identifier hs-var hs-var">strTyLit</span></a></span></span><span> </span><span id="local-6989586621679165144"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679165144"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TyLit -&gt; m TyLit
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; TyLit
</span><a href="Language.Haskell.TH.Syntax.html#StrTyLit"><span class="hs-identifier hs-var">StrTyLit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679165144"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-833"></span><span>
</span><span id="line-834"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-835"></span><span class="hs-comment">-- *   Kind</span><span>
</span><span id="line-836"></span><span>
</span><span id="line-837"></span><span id="local-6989586621679166936"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#plainTV"><span class="hs-identifier hs-type">plainTV</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166936"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166936"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span></span><span>
</span><span id="line-838"></span><span id="plainTV"><span class="annot"><span class="annottext">plainTV :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m (TyVarBndr ())
</span><a href="Language.Haskell.TH.Lib.Internal.html#plainTV"><span class="hs-identifier hs-var hs-var">plainTV</span></a></span></span><span> </span><span id="local-6989586621679165138"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165138"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TyVarBndr () -&gt; m (TyVarBndr ())
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(TyVarBndr () -&gt; m (TyVarBndr ()))
-&gt; TyVarBndr () -&gt; m (TyVarBndr ())
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Name -&gt; () -&gt; TyVarBndr ()
forall flag. Name -&gt; flag -&gt; TyVarBndr flag
</span><a href="Language.Haskell.TH.Syntax.html#PlainTV"><span class="hs-identifier hs-var">PlainTV</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165138"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-839"></span><span>
</span><span id="line-840"></span><span id="local-6989586621679166933"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#plainInvisTV"><span class="hs-identifier hs-type">plainInvisTV</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166933"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Specificity"><span class="hs-identifier hs-type">Specificity</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166933"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Specificity"><span class="hs-identifier hs-type">Specificity</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-841"></span><span id="plainInvisTV"><span class="annot"><span class="annottext">plainInvisTV :: forall (m :: * -&gt; *).
Quote m =&gt;
Name -&gt; Specificity -&gt; m (TyVarBndr Specificity)
</span><a href="Language.Haskell.TH.Lib.Internal.html#plainInvisTV"><span class="hs-identifier hs-var hs-var">plainInvisTV</span></a></span></span><span> </span><span id="local-6989586621679165132"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165132"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679165131"><span class="annot"><span class="annottext">Specificity
</span><a href="#local-6989586621679165131"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TyVarBndr Specificity -&gt; m (TyVarBndr Specificity)
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(TyVarBndr Specificity -&gt; m (TyVarBndr Specificity))
-&gt; TyVarBndr Specificity -&gt; m (TyVarBndr Specificity)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Name -&gt; Specificity -&gt; TyVarBndr Specificity
forall flag. Name -&gt; flag -&gt; TyVarBndr flag
</span><a href="Language.Haskell.TH.Syntax.html#PlainTV"><span class="hs-identifier hs-var">PlainTV</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165132"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Specificity
</span><a href="#local-6989586621679165131"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-842"></span><span>
</span><span id="line-843"></span><span id="local-6989586621679166931"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#kindedTV"><span class="hs-identifier hs-type">kindedTV</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166931"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166931"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166931"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span></span><span>
</span><span id="line-844"></span><span id="kindedTV"><span class="annot"><span class="annottext">kindedTV :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Type -&gt; m (TyVarBndr ())
</span><a href="Language.Haskell.TH.Lib.Internal.html#kindedTV"><span class="hs-identifier hs-var hs-var">kindedTV</span></a></span></span><span> </span><span id="local-6989586621679165125"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165125"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Type -&gt; TyVarBndr ()) -&gt; m Type -&gt; m (TyVarBndr ())
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; () -&gt; Type -&gt; TyVarBndr ()
forall flag. Name -&gt; flag -&gt; Type -&gt; TyVarBndr flag
</span><a href="Language.Haskell.TH.Syntax.html#KindedTV"><span class="hs-identifier hs-var">KindedTV</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165125"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-845"></span><span>
</span><span id="line-846"></span><span id="local-6989586621679166929"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#kindedInvisTV"><span class="hs-identifier hs-type">kindedInvisTV</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166929"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Specificity"><span class="hs-identifier hs-type">Specificity</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166929"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166929"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Specificity"><span class="hs-identifier hs-type">Specificity</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-847"></span><span id="kindedInvisTV"><span class="annot"><span class="annottext">kindedInvisTV :: forall (m :: * -&gt; *).
Quote m =&gt;
Name -&gt; Specificity -&gt; m Type -&gt; m (TyVarBndr Specificity)
</span><a href="Language.Haskell.TH.Lib.Internal.html#kindedInvisTV"><span class="hs-identifier hs-var hs-var">kindedInvisTV</span></a></span></span><span> </span><span id="local-6989586621679165118"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165118"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679165117"><span class="annot"><span class="annottext">Specificity
</span><a href="#local-6989586621679165117"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Type -&gt; TyVarBndr Specificity)
-&gt; m Type -&gt; m (TyVarBndr Specificity)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; Specificity -&gt; Type -&gt; TyVarBndr Specificity
forall flag. Name -&gt; flag -&gt; Type -&gt; TyVarBndr flag
</span><a href="Language.Haskell.TH.Syntax.html#KindedTV"><span class="hs-identifier hs-var">KindedTV</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165118"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Specificity
</span><a href="#local-6989586621679165117"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-848"></span><span>
</span><span id="line-849"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#specifiedSpec"><span class="hs-identifier hs-type">specifiedSpec</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Specificity"><span class="hs-identifier hs-type">Specificity</span></a></span><span>
</span><span id="line-850"></span><span id="specifiedSpec"><span class="annot"><span class="annottext">specifiedSpec :: Specificity
</span><a href="Language.Haskell.TH.Lib.Internal.html#specifiedSpec"><span class="hs-identifier hs-var hs-var">specifiedSpec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Specificity
</span><a href="Language.Haskell.TH.Syntax.html#SpecifiedSpec"><span class="hs-identifier hs-var">SpecifiedSpec</span></a></span><span>
</span><span id="line-851"></span><span>
</span><span id="line-852"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#inferredSpec"><span class="hs-identifier hs-type">inferredSpec</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Specificity"><span class="hs-identifier hs-type">Specificity</span></a></span><span>
</span><span id="line-853"></span><span id="inferredSpec"><span class="annot"><span class="annottext">inferredSpec :: Specificity
</span><a href="Language.Haskell.TH.Lib.Internal.html#inferredSpec"><span class="hs-identifier hs-var hs-var">inferredSpec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Specificity
</span><a href="Language.Haskell.TH.Syntax.html#InferredSpec"><span class="hs-identifier hs-var">InferredSpec</span></a></span><span>
</span><span id="line-854"></span><span>
</span><span id="line-855"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#varK"><span class="hs-identifier hs-type">varK</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span>
</span><span id="line-856"></span><span id="varK"><span class="annot"><span class="annottext">varK :: Name -&gt; Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#varK"><span class="hs-identifier hs-var hs-var">varK</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#VarT"><span class="hs-identifier hs-var">VarT</span></a></span><span>
</span><span id="line-857"></span><span>
</span><span id="line-858"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#conK"><span class="hs-identifier hs-type">conK</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span>
</span><span id="line-859"></span><span id="conK"><span class="annot"><span class="annottext">conK :: Name -&gt; Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#conK"><span class="hs-identifier hs-var hs-var">conK</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#ConT"><span class="hs-identifier hs-var">ConT</span></a></span><span>
</span><span id="line-860"></span><span>
</span><span id="line-861"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tupleK"><span class="hs-identifier hs-type">tupleK</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span>
</span><span id="line-862"></span><span id="tupleK"><span class="annot"><span class="annottext">tupleK :: SumAlt -&gt; Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#tupleK"><span class="hs-identifier hs-var hs-var">tupleK</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">SumAlt -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#TupleT"><span class="hs-identifier hs-var">TupleT</span></a></span><span>
</span><span id="line-863"></span><span>
</span><span id="line-864"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#arrowK"><span class="hs-identifier hs-type">arrowK</span></a></span><span> </span><span class="hs-glyph">::</span><span>  </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span>
</span><span id="line-865"></span><span id="arrowK"><span class="annot"><span class="annottext">arrowK :: Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#arrowK"><span class="hs-identifier hs-var hs-var">arrowK</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="Language.Haskell.TH.Syntax.html#ArrowT"><span class="hs-identifier hs-var">ArrowT</span></a></span><span>
</span><span id="line-866"></span><span>
</span><span id="line-867"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#listK"><span class="hs-identifier hs-type">listK</span></a></span><span> </span><span class="hs-glyph">::</span><span>  </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span>
</span><span id="line-868"></span><span id="listK"><span class="annot"><span class="annottext">listK :: Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#listK"><span class="hs-identifier hs-var hs-var">listK</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="Language.Haskell.TH.Syntax.html#ListT"><span class="hs-identifier hs-var">ListT</span></a></span><span>
</span><span id="line-869"></span><span>
</span><span id="line-870"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#appK"><span class="hs-identifier hs-type">appK</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span>
</span><span id="line-871"></span><span id="appK"><span class="annot"><span class="annottext">appK :: Type -&gt; Type -&gt; Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#appK"><span class="hs-identifier hs-var hs-var">appK</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#AppT"><span class="hs-identifier hs-var">AppT</span></a></span><span>
</span><span id="line-872"></span><span>
</span><span id="line-873"></span><span id="local-6989586621679165108"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#starK"><span class="hs-identifier hs-type">starK</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165108"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165108"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span></span><span>
</span><span id="line-874"></span><span id="starK"><span class="annot"><span class="annottext">starK :: forall (m :: * -&gt; *). Quote m =&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#starK"><span class="hs-identifier hs-var hs-var">starK</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="Language.Haskell.TH.Syntax.html#StarT"><span class="hs-identifier hs-var">StarT</span></a></span><span>
</span><span id="line-875"></span><span>
</span><span id="line-876"></span><span id="local-6989586621679165102"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#constraintK"><span class="hs-identifier hs-type">constraintK</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165102"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165102"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span></span><span>
</span><span id="line-877"></span><span id="constraintK"><span class="annot"><span class="annottext">constraintK :: forall (m :: * -&gt; *). Quote m =&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#constraintK"><span class="hs-identifier hs-var hs-var">constraintK</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="Language.Haskell.TH.Syntax.html#ConstraintT"><span class="hs-identifier hs-var">ConstraintT</span></a></span><span>
</span><span id="line-878"></span><span>
</span><span id="line-879"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-880"></span><span class="hs-comment">-- *   Type family result</span><span>
</span><span id="line-881"></span><span>
</span><span id="line-882"></span><span id="local-6989586621679166925"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#noSig"><span class="hs-identifier hs-type">noSig</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166925"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166925"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FamilyResultSig"><span class="hs-identifier hs-type">FamilyResultSig</span></a></span></span><span>
</span><span id="line-883"></span><span id="noSig"><span class="annot"><span class="annottext">noSig :: forall (m :: * -&gt; *). Quote m =&gt; m FamilyResultSig
</span><a href="Language.Haskell.TH.Lib.Internal.html#noSig"><span class="hs-identifier hs-var hs-var">noSig</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">FamilyResultSig -&gt; m FamilyResultSig
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">FamilyResultSig
</span><a href="Language.Haskell.TH.Syntax.html#NoSig"><span class="hs-identifier hs-var">NoSig</span></a></span><span>
</span><span id="line-884"></span><span>
</span><span id="line-885"></span><span id="local-6989586621679166923"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#kindSig"><span class="hs-identifier hs-type">kindSig</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166923"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166923"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166923"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FamilyResultSig"><span class="hs-identifier hs-type">FamilyResultSig</span></a></span></span><span>
</span><span id="line-886"></span><span id="kindSig"><span class="annot"><span class="annottext">kindSig :: forall (m :: * -&gt; *). Quote m =&gt; m Type -&gt; m FamilyResultSig
</span><a href="Language.Haskell.TH.Lib.Internal.html#kindSig"><span class="hs-identifier hs-var hs-var">kindSig</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Type -&gt; FamilyResultSig) -&gt; m Type -&gt; m FamilyResultSig
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; FamilyResultSig
</span><a href="Language.Haskell.TH.Syntax.html#KindSig"><span class="hs-identifier hs-var">KindSig</span></a></span><span>
</span><span id="line-887"></span><span>
</span><span id="line-888"></span><span id="local-6989586621679166921"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tyVarSig"><span class="hs-identifier hs-type">tyVarSig</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166921"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166921"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166921"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FamilyResultSig"><span class="hs-identifier hs-type">FamilyResultSig</span></a></span></span><span>
</span><span id="line-889"></span><span id="tyVarSig"><span class="annot"><span class="annottext">tyVarSig :: forall (m :: * -&gt; *).
Quote m =&gt;
m (TyVarBndr ()) -&gt; m FamilyResultSig
</span><a href="Language.Haskell.TH.Lib.Internal.html#tyVarSig"><span class="hs-identifier hs-var hs-var">tyVarSig</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(TyVarBndr () -&gt; FamilyResultSig)
-&gt; m (TyVarBndr ()) -&gt; m FamilyResultSig
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">TyVarBndr () -&gt; FamilyResultSig
</span><a href="Language.Haskell.TH.Syntax.html#TyVarSig"><span class="hs-identifier hs-var">TyVarSig</span></a></span><span>
</span><span id="line-890"></span><span>
</span><span id="line-891"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-892"></span><span class="hs-comment">-- *   Injectivity annotation</span><span>
</span><span id="line-893"></span><span>
</span><span id="line-894"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#injectivityAnn"><span class="hs-identifier hs-type">injectivityAnn</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#InjectivityAnn"><span class="hs-identifier hs-type">InjectivityAnn</span></a></span><span>
</span><span id="line-895"></span><span id="injectivityAnn"><span class="annot"><span class="annottext">injectivityAnn :: Name -&gt; [Name] -&gt; InjectivityAnn
</span><a href="Language.Haskell.TH.Lib.Internal.html#injectivityAnn"><span class="hs-identifier hs-var hs-var">injectivityAnn</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name -&gt; [Name] -&gt; InjectivityAnn
</span><a href="Language.Haskell.TH.Syntax.html#InjectivityAnn"><span class="hs-identifier hs-var">TH.InjectivityAnn</span></a></span><span>
</span><span id="line-896"></span><span>
</span><span id="line-897"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-898"></span><span class="hs-comment">-- *   Role</span><span>
</span><span id="line-899"></span><span>
</span><span id="line-900"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#nominalR"><span class="hs-identifier hs-type">nominalR</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#representationalR"><span class="hs-identifier hs-type">representationalR</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#phantomR"><span class="hs-identifier hs-type">phantomR</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#inferR"><span class="hs-identifier hs-type">inferR</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#Role"><span class="hs-identifier hs-type">Role</span></a></span><span>
</span><span id="line-901"></span><span id="nominalR"><span class="annot"><span class="annottext">nominalR :: Role
</span><a href="Language.Haskell.TH.Lib.Internal.html#nominalR"><span class="hs-identifier hs-var hs-var">nominalR</span></a></span></span><span>          </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Role
</span><a href="Language.Haskell.TH.Syntax.html#NominalR"><span class="hs-identifier hs-var">NominalR</span></a></span><span>
</span><span id="line-902"></span><span id="representationalR"><span class="annot"><span class="annottext">representationalR :: Role
</span><a href="Language.Haskell.TH.Lib.Internal.html#representationalR"><span class="hs-identifier hs-var hs-var">representationalR</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Role
</span><a href="Language.Haskell.TH.Syntax.html#RepresentationalR"><span class="hs-identifier hs-var">RepresentationalR</span></a></span><span>
</span><span id="line-903"></span><span id="phantomR"><span class="annot"><span class="annottext">phantomR :: Role
</span><a href="Language.Haskell.TH.Lib.Internal.html#phantomR"><span class="hs-identifier hs-var hs-var">phantomR</span></a></span></span><span>          </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Role
</span><a href="Language.Haskell.TH.Syntax.html#PhantomR"><span class="hs-identifier hs-var">PhantomR</span></a></span><span>
</span><span id="line-904"></span><span id="inferR"><span class="annot"><span class="annottext">inferR :: Role
</span><a href="Language.Haskell.TH.Lib.Internal.html#inferR"><span class="hs-identifier hs-var hs-var">inferR</span></a></span></span><span>            </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Role
</span><a href="Language.Haskell.TH.Syntax.html#InferR"><span class="hs-identifier hs-var">InferR</span></a></span><span>
</span><span id="line-905"></span><span>
</span><span id="line-906"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-907"></span><span class="hs-comment">-- *   Callconv</span><span>
</span><span id="line-908"></span><span>
</span><span id="line-909"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#cCall"><span class="hs-identifier hs-type">cCall</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#stdCall"><span class="hs-identifier hs-type">stdCall</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#cApi"><span class="hs-identifier hs-type">cApi</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#prim"><span class="hs-keyword hs-type">prim</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#javaScript"><span class="hs-identifier hs-type">javaScript</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Callconv"><span class="hs-identifier hs-type">Callconv</span></a></span><span>
</span><span id="line-910"></span><span id="cCall"><span class="annot"><span class="annottext">cCall :: Callconv
</span><a href="Language.Haskell.TH.Lib.Internal.html#cCall"><span class="hs-identifier hs-var hs-var">cCall</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Callconv
</span><a href="Language.Haskell.TH.Syntax.html#CCall"><span class="hs-identifier hs-var">CCall</span></a></span><span>
</span><span id="line-911"></span><span id="stdCall"><span class="annot"><span class="annottext">stdCall :: Callconv
</span><a href="Language.Haskell.TH.Lib.Internal.html#stdCall"><span class="hs-identifier hs-var hs-var">stdCall</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Callconv
</span><a href="Language.Haskell.TH.Syntax.html#StdCall"><span class="hs-identifier hs-var">StdCall</span></a></span><span>
</span><span id="line-912"></span><span id="cApi"><span class="annot"><span class="annottext">cApi :: Callconv
</span><a href="Language.Haskell.TH.Lib.Internal.html#cApi"><span class="hs-identifier hs-var hs-var">cApi</span></a></span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Callconv
</span><a href="Language.Haskell.TH.Syntax.html#CApi"><span class="hs-identifier hs-var">CApi</span></a></span><span>
</span><span id="line-913"></span><span id="prim"><span class="annot"><span class="annottext">prim :: Callconv
</span><a href="Language.Haskell.TH.Lib.Internal.html#prim"><span class="hs-keyword hs-var hs-var">prim</span></a></span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Callconv
</span><a href="Language.Haskell.TH.Syntax.html#Prim"><span class="hs-identifier hs-var">Prim</span></a></span><span>
</span><span id="line-914"></span><span id="javaScript"><span class="annot"><span class="annottext">javaScript :: Callconv
</span><a href="Language.Haskell.TH.Lib.Internal.html#javaScript"><span class="hs-identifier hs-var hs-var">javaScript</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Callconv
</span><a href="Language.Haskell.TH.Syntax.html#JavaScript"><span class="hs-identifier hs-var">JavaScript</span></a></span><span>
</span><span id="line-915"></span><span>
</span><span id="line-916"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-917"></span><span class="hs-comment">-- *   Safety</span><span>
</span><span id="line-918"></span><span>
</span><span id="line-919"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unsafe"><span class="hs-keyword hs-type">unsafe</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#safe"><span class="hs-keyword hs-type">safe</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#interruptible"><span class="hs-identifier hs-type">interruptible</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Safety"><span class="hs-identifier hs-type">Safety</span></a></span><span>
</span><span id="line-920"></span><span id="unsafe"><span class="annot"><span class="annottext">unsafe :: Safety
</span><a href="Language.Haskell.TH.Lib.Internal.html#unsafe"><span class="hs-keyword hs-var hs-var">unsafe</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Safety
</span><a href="Language.Haskell.TH.Syntax.html#Unsafe"><span class="hs-identifier hs-var">Unsafe</span></a></span><span>
</span><span id="line-921"></span><span id="safe"><span class="annot"><span class="annottext">safe :: Safety
</span><a href="Language.Haskell.TH.Lib.Internal.html#safe"><span class="hs-keyword hs-var hs-var">safe</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Safety
</span><a href="Language.Haskell.TH.Syntax.html#Safe"><span class="hs-identifier hs-var">Safe</span></a></span><span>
</span><span id="line-922"></span><span id="interruptible"><span class="annot"><span class="annottext">interruptible :: Safety
</span><a href="Language.Haskell.TH.Lib.Internal.html#interruptible"><span class="hs-identifier hs-var hs-var">interruptible</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Safety
</span><a href="Language.Haskell.TH.Syntax.html#Interruptible"><span class="hs-identifier hs-var">Interruptible</span></a></span><span>
</span><span id="line-923"></span><span>
</span><span id="line-924"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-925"></span><span class="hs-comment">-- *   FunDep</span><span>
</span><span id="line-926"></span><span>
</span><span id="line-927"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#funDep"><span class="hs-identifier hs-type">funDep</span></a></span><span> </span><span class="hs-glyph">::</span><span>  </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FunDep"><span class="hs-identifier hs-type">FunDep</span></a></span><span>
</span><span id="line-928"></span><span id="funDep"><span class="annot"><span class="annottext">funDep :: [Name] -&gt; [Name] -&gt; FunDep
</span><a href="Language.Haskell.TH.Lib.Internal.html#funDep"><span class="hs-identifier hs-var hs-var">funDep</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Name] -&gt; [Name] -&gt; FunDep
</span><a href="Language.Haskell.TH.Syntax.html#FunDep"><span class="hs-identifier hs-var">FunDep</span></a></span><span>
</span><span id="line-929"></span><span>
</span><span id="line-930"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-931"></span><span class="hs-comment">-- *   RuleBndr</span><span>
</span><span id="line-932"></span><span id="local-6989586621679166919"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#ruleVar"><span class="hs-identifier hs-type">ruleVar</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166919"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166919"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#RuleBndr"><span class="hs-identifier hs-type">RuleBndr</span></a></span></span><span>
</span><span id="line-933"></span><span id="ruleVar"><span class="annot"><span class="annottext">ruleVar :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m RuleBndr
</span><a href="Language.Haskell.TH.Lib.Internal.html#ruleVar"><span class="hs-identifier hs-var hs-var">ruleVar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">RuleBndr -&gt; m RuleBndr
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(RuleBndr -&gt; m RuleBndr)
-&gt; (Name -&gt; RuleBndr) -&gt; Name -&gt; m RuleBndr
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Name -&gt; RuleBndr
</span><a href="Language.Haskell.TH.Syntax.html#RuleVar"><span class="hs-identifier hs-var">RuleVar</span></a></span><span>
</span><span id="line-934"></span><span>
</span><span id="line-935"></span><span id="local-6989586621679166917"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#typedRuleVar"><span class="hs-identifier hs-type">typedRuleVar</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166917"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166917"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166917"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#RuleBndr"><span class="hs-identifier hs-type">RuleBndr</span></a></span></span><span>
</span><span id="line-936"></span><span id="typedRuleVar"><span class="annot"><span class="annottext">typedRuleVar :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Type -&gt; m RuleBndr
</span><a href="Language.Haskell.TH.Lib.Internal.html#typedRuleVar"><span class="hs-identifier hs-var hs-var">typedRuleVar</span></a></span></span><span> </span><span id="local-6989586621679165056"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165056"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679165055"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165055"><span class="hs-identifier hs-var">ty</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name -&gt; Type -&gt; RuleBndr
</span><a href="Language.Haskell.TH.Syntax.html#TypedRuleVar"><span class="hs-identifier hs-var">TypedRuleVar</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165056"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">(Type -&gt; RuleBndr) -&gt; m Type -&gt; m RuleBndr
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679165055"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-937"></span><span>
</span><span id="line-938"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-939"></span><span class="hs-comment">-- *   AnnTarget</span><span>
</span><span id="line-940"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#valueAnnotation"><span class="hs-identifier hs-type">valueAnnotation</span></a></span><span> </span><span class="hs-glyph">::</span><span>  </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#AnnTarget"><span class="hs-identifier hs-type">AnnTarget</span></a></span><span>
</span><span id="line-941"></span><span id="valueAnnotation"><span class="annot"><span class="annottext">valueAnnotation :: Name -&gt; AnnTarget
</span><a href="Language.Haskell.TH.Lib.Internal.html#valueAnnotation"><span class="hs-identifier hs-var hs-var">valueAnnotation</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name -&gt; AnnTarget
</span><a href="Language.Haskell.TH.Syntax.html#ValueAnnotation"><span class="hs-identifier hs-var">ValueAnnotation</span></a></span><span>
</span><span id="line-942"></span><span>
</span><span id="line-943"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#typeAnnotation"><span class="hs-identifier hs-type">typeAnnotation</span></a></span><span> </span><span class="hs-glyph">::</span><span>  </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#AnnTarget"><span class="hs-identifier hs-type">AnnTarget</span></a></span><span>
</span><span id="line-944"></span><span id="typeAnnotation"><span class="annot"><span class="annottext">typeAnnotation :: Name -&gt; AnnTarget
</span><a href="Language.Haskell.TH.Lib.Internal.html#typeAnnotation"><span class="hs-identifier hs-var hs-var">typeAnnotation</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name -&gt; AnnTarget
</span><a href="Language.Haskell.TH.Syntax.html#TypeAnnotation"><span class="hs-identifier hs-var">TypeAnnotation</span></a></span><span>
</span><span id="line-945"></span><span>
</span><span id="line-946"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#moduleAnnotation"><span class="hs-identifier hs-type">moduleAnnotation</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#AnnTarget"><span class="hs-identifier hs-type">AnnTarget</span></a></span><span>
</span><span id="line-947"></span><span id="moduleAnnotation"><span class="annot"><span class="annottext">moduleAnnotation :: AnnTarget
</span><a href="Language.Haskell.TH.Lib.Internal.html#moduleAnnotation"><span class="hs-identifier hs-var hs-var">moduleAnnotation</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">AnnTarget
</span><a href="Language.Haskell.TH.Syntax.html#ModuleAnnotation"><span class="hs-identifier hs-var">ModuleAnnotation</span></a></span><span>
</span><span id="line-948"></span><span>
</span><span id="line-949"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-950"></span><span class="hs-comment">-- * Pattern Synonyms (sub constructs)</span><span>
</span><span id="line-951"></span><span>
</span><span id="line-952"></span><span id="local-6989586621679166915"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unidir"><span class="hs-identifier hs-type">unidir</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#implBidir"><span class="hs-identifier hs-type">implBidir</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166915"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166915"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#PatSynDir"><span class="hs-identifier hs-type">PatSynDir</span></a></span></span><span>
</span><span id="line-953"></span><span id="unidir"><span class="annot"><span class="annottext">unidir :: forall (m :: * -&gt; *). Quote m =&gt; m PatSynDir
</span><a href="Language.Haskell.TH.Lib.Internal.html#unidir"><span class="hs-identifier hs-var hs-var">unidir</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">PatSynDir -&gt; m PatSynDir
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">PatSynDir
</span><a href="Language.Haskell.TH.Syntax.html#Unidir"><span class="hs-identifier hs-var">Unidir</span></a></span><span>
</span><span id="line-954"></span><span id="implBidir"><span class="annot"><span class="annottext">implBidir :: forall (m :: * -&gt; *). Quote m =&gt; m PatSynDir
</span><a href="Language.Haskell.TH.Lib.Internal.html#implBidir"><span class="hs-identifier hs-var hs-var">implBidir</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">PatSynDir -&gt; m PatSynDir
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">PatSynDir
</span><a href="Language.Haskell.TH.Syntax.html#ImplBidir"><span class="hs-identifier hs-var">ImplBidir</span></a></span><span>
</span><span id="line-955"></span><span>
</span><span id="line-956"></span><span id="local-6989586621679166912"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#explBidir"><span class="hs-identifier hs-type">explBidir</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166912"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679166912"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Clause"><span class="hs-identifier hs-type">Clause</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166912"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#PatSynDir"><span class="hs-identifier hs-type">PatSynDir</span></a></span></span><span>
</span><span id="line-957"></span><span id="explBidir"><span class="annot"><span class="annottext">explBidir :: forall (m :: * -&gt; *). Quote m =&gt; [m Clause] -&gt; m PatSynDir
</span><a href="Language.Haskell.TH.Lib.Internal.html#explBidir"><span class="hs-identifier hs-var hs-var">explBidir</span></a></span></span><span> </span><span id="local-6989586621679165033"><span class="annot"><span class="annottext">[m Clause]
</span><a href="#local-6989586621679165033"><span class="hs-identifier hs-var">cls</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-958"></span><span>  </span><span id="local-6989586621679165032"><span class="annot"><span class="annottext">[Clause]
</span><a href="#local-6989586621679165032"><span class="hs-identifier hs-var">cls'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Clause] -&gt; m [Clause]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Clause]
</span><a href="#local-6989586621679165033"><span class="hs-identifier hs-var">cls</span></a></span><span>
</span><span id="line-959"></span><span>  </span><span class="annot"><span class="annottext">PatSynDir -&gt; m PatSynDir
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Clause] -&gt; PatSynDir
</span><a href="Language.Haskell.TH.Syntax.html#ExplBidir"><span class="hs-identifier hs-var">ExplBidir</span></a></span><span> </span><span class="annot"><span class="annottext">[Clause]
</span><a href="#local-6989586621679165032"><span class="hs-identifier hs-var">cls'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-960"></span><span>
</span><span id="line-961"></span><span id="local-6989586621679166910"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#prefixPatSyn"><span class="hs-identifier hs-type">prefixPatSyn</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166910"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166910"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#PatSynArgs"><span class="hs-identifier hs-type">PatSynArgs</span></a></span></span><span>
</span><span id="line-962"></span><span id="prefixPatSyn"><span class="annot"><span class="annottext">prefixPatSyn :: forall (m :: * -&gt; *). Quote m =&gt; [Name] -&gt; m PatSynArgs
</span><a href="Language.Haskell.TH.Lib.Internal.html#prefixPatSyn"><span class="hs-identifier hs-var hs-var">prefixPatSyn</span></a></span></span><span> </span><span id="local-6989586621679165026"><span class="annot"><span class="annottext">[Name]
</span><a href="#local-6989586621679165026"><span class="hs-identifier hs-var">args</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">PatSynArgs -&gt; m PatSynArgs
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(PatSynArgs -&gt; m PatSynArgs) -&gt; PatSynArgs -&gt; m PatSynArgs
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">[Name] -&gt; PatSynArgs
</span><a href="Language.Haskell.TH.Syntax.html#PrefixPatSyn"><span class="hs-identifier hs-var">PrefixPatSyn</span></a></span><span> </span><span class="annot"><span class="annottext">[Name]
</span><a href="#local-6989586621679165026"><span class="hs-identifier hs-var">args</span></a></span><span>
</span><span id="line-963"></span><span>
</span><span id="line-964"></span><span id="local-6989586621679165024"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#recordPatSyn"><span class="hs-identifier hs-type">recordPatSyn</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165024"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165024"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#PatSynArgs"><span class="hs-identifier hs-type">PatSynArgs</span></a></span></span><span>
</span><span id="line-965"></span><span id="recordPatSyn"><span class="annot"><span class="annottext">recordPatSyn :: forall (m :: * -&gt; *). Quote m =&gt; [Name] -&gt; m PatSynArgs
</span><a href="Language.Haskell.TH.Lib.Internal.html#recordPatSyn"><span class="hs-identifier hs-var hs-var">recordPatSyn</span></a></span></span><span> </span><span id="local-6989586621679165019"><span class="annot"><span class="annottext">[Name]
</span><a href="#local-6989586621679165019"><span class="hs-identifier hs-var">sels</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">PatSynArgs -&gt; m PatSynArgs
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(PatSynArgs -&gt; m PatSynArgs) -&gt; PatSynArgs -&gt; m PatSynArgs
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">[Name] -&gt; PatSynArgs
</span><a href="Language.Haskell.TH.Syntax.html#RecordPatSyn"><span class="hs-identifier hs-var">RecordPatSyn</span></a></span><span> </span><span class="annot"><span class="annottext">[Name]
</span><a href="#local-6989586621679165019"><span class="hs-identifier hs-var">sels</span></a></span><span>
</span><span id="line-966"></span><span>
</span><span id="line-967"></span><span id="local-6989586621679166907"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixPatSyn"><span class="hs-identifier hs-type">infixPatSyn</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679166907"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679166907"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#PatSynArgs"><span class="hs-identifier hs-type">PatSynArgs</span></a></span></span><span>
</span><span id="line-968"></span><span id="infixPatSyn"><span class="annot"><span class="annottext">infixPatSyn :: forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; Name -&gt; m PatSynArgs
</span><a href="Language.Haskell.TH.Lib.Internal.html#infixPatSyn"><span class="hs-identifier hs-var hs-var">infixPatSyn</span></a></span></span><span> </span><span id="local-6989586621679165013"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165013"><span class="hs-identifier hs-var">arg1</span></a></span></span><span> </span><span id="local-6989586621679165012"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165012"><span class="hs-identifier hs-var">arg2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">PatSynArgs -&gt; m PatSynArgs
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(PatSynArgs -&gt; m PatSynArgs) -&gt; PatSynArgs -&gt; m PatSynArgs
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Name -&gt; Name -&gt; PatSynArgs
</span><a href="Language.Haskell.TH.Syntax.html#InfixPatSyn"><span class="hs-identifier hs-var">InfixPatSyn</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165013"><span class="hs-identifier hs-var">arg1</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679165012"><span class="hs-identifier hs-var">arg2</span></a></span><span>
</span><span id="line-969"></span><span>
</span><span id="line-970"></span><span class="hs-comment">--------------------------------------------------------------</span><span>
</span><span id="line-971"></span><span class="hs-comment">-- * Useful helper function</span><span>
</span><span id="line-972"></span><span>
</span><span id="line-973"></span><span id="local-6989586621679165010"><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#appsE"><span class="hs-identifier hs-type">appsE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679165010"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679165010"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679165010"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-974"></span><span id="appsE"><span class="annot"><span class="annottext">appsE :: forall (m :: * -&gt; *). Quote m =&gt; [m Exp] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#appsE"><span class="hs-identifier hs-var hs-var">appsE</span></a></span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; m Exp
forall a. HasCallStack =&gt; String -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;appsE []&quot;</span></span><span>
</span><span id="line-975"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#appsE"><span class="hs-identifier hs-var">appsE</span></a></span><span> </span><span class="hs-special">[</span><span id="local-6989586621679165003"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679165003"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679165003"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-976"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#appsE"><span class="hs-identifier hs-var">appsE</span></a></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679165002"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679165002"><span class="hs-identifier hs-var">x</span></a></span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span id="local-6989586621679165001"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679165001"><span class="hs-identifier hs-var">y</span></a></span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span id="local-6989586621679165000"><span class="annot"><span class="annottext">[m Exp]
</span><a href="#local-6989586621679165000"><span class="hs-identifier hs-var">zs</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[m Exp] -&gt; m Exp
forall (m :: * -&gt; *). Quote m =&gt; [m Exp] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#appsE"><span class="hs-identifier hs-var">appsE</span></a></span><span> </span><span class="hs-special">(</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m Exp -&gt; m Exp -&gt; m Exp
forall (m :: * -&gt; *). Quote m =&gt; m Exp -&gt; m Exp -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#appE"><span class="hs-identifier hs-var">appE</span></a></span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679165002"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679165001"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m Exp -&gt; [m Exp] -&gt; [m Exp]
forall a. a -&gt; [a] -&gt; [a]
</span><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-var">:</span></a></span><span> </span><span class="annot"><span class="annottext">[m Exp]
</span><a href="#local-6989586621679165000"><span class="hs-identifier hs-var">zs</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-977"></span><span>
</span><span id="line-978"></span><span class="hs-comment">-- | pure the Module at the place of splicing.  Can be used as an</span><span>
</span><span id="line-979"></span><span class="hs-comment">-- input for 'reifyModule'.</span><span>
</span><span id="line-980"></span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#thisModule"><span class="hs-identifier hs-type">thisModule</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Q"><span class="hs-identifier hs-type">Q</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Module"><span class="hs-identifier hs-type">Module</span></a></span><span>
</span><span id="line-981"></span><span id="thisModule"><span class="annot"><span class="annottext">thisModule :: Q Module
</span><a href="Language.Haskell.TH.Lib.Internal.html#thisModule"><span class="hs-identifier hs-var hs-var">thisModule</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-982"></span><span>  </span><span id="local-6989586621679164998"><span class="annot"><span class="annottext">Loc
</span><a href="#local-6989586621679164998"><span class="hs-identifier hs-var">loc</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Q Loc
</span><a href="Language.Haskell.TH.Syntax.html#location"><span class="hs-identifier hs-var">location</span></a></span><span>
</span><span id="line-983"></span><span>  </span><span class="annot"><span class="annottext">Module -&gt; Q Module
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Module -&gt; Q Module) -&gt; Module -&gt; Q Module
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">PkgName -&gt; ModName -&gt; Module
</span><a href="Language.Haskell.TH.Syntax.html#Module"><span class="hs-identifier hs-var">Module</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; PkgName
</span><a href="Language.Haskell.TH.Syntax.html#mkPkgName"><span class="hs-identifier hs-var">mkPkgName</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; PkgName) -&gt; String -&gt; PkgName
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Loc -&gt; String
</span><a href="Language.Haskell.TH.Syntax.html#loc_package"><span class="hs-identifier hs-var hs-var">loc_package</span></a></span><span> </span><span class="annot"><span class="annottext">Loc
</span><a href="#local-6989586621679164998"><span class="hs-identifier hs-var">loc</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; ModName
</span><a href="Language.Haskell.TH.Syntax.html#mkModName"><span class="hs-identifier hs-var">mkModName</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; ModName) -&gt; String -&gt; ModName
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Loc -&gt; String
</span><a href="Language.Haskell.TH.Syntax.html#loc_module"><span class="hs-identifier hs-var hs-var">loc_module</span></a></span><span> </span><span class="annot"><span class="annottext">Loc
</span><a href="#local-6989586621679164998"><span class="hs-identifier hs-var">loc</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-984"></span></pre></body></html>